jackherd 1.26.1 → 1.26.3

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 What changed for people who use jackherd, newest first.
 
+## 1.26.3
+
+- **`jh lane close` no longer refuses a lane for files a project deletes on every close.** `lanes.disposable` in `.jackherd/config.json` lists ignored paths in `.gitignore` syntax (scratch folders, stored test logins, generated assets) that go with the worktree without a refusal; any other ignored file still refuses.
+- **`jh lane close` archives the lane's handover files instead of refusing.** Before the worktree is removed, `.claude/handover/` is copied to `.claude/handover/closed/<lane>-<date>/` in the main checkout; when the copy fails, nothing is removed. The orchestrate skill's `close-lane.md` says so. Run `jh sync` to get the text.
+- **`jh lane close` deletes the lane's branch on origin when nothing was pushed after the merge.** The branch goes only while it still points to the merged pull request's head, as the last step so a failed push leaves the rest done; otherwise one line says why it stays. `jh lane close <lane> --branch <branch>` finishes it for a lane closed before.
+
+## 1.26.2
+
+- **A board lane is placed by its agent's worktree.** The herd and the watcher find a lane by the worktree its agent runs in, not only by the lane's name.
+- **`jh sync` refuses a sync that would turn the repo's kit files back.** When the installed jackherd is older than the version in the repo's lock, the sync stops and names both versions instead of overwriting newer kit files. Run `jh update` first.
+- **`jh update` waits for the registry after a publish.** A 404 right after a release no longer fails the update; it retries until the registry has the version.
+- **`jh lane send` refuses while a background agent's view is open.** The text no longer lands in the subagent view instead of the lane's session.
+
 ## 1.26.1
 
 - **A lane whose agent runs in a worktree of another name is no longer silently unwatched.** The watcher finds a lane by its worktree directory's name, so a board lane whose agent runs in a worktree taken over from another session never sent an event. The watcher now prints `lane <name> not watched: its agent runs in worktree <dir>, not <name>` once when it appears, and `jh resume --coordinator` lists it too. The orchestrate skill's `lane-session.md` says to name the lane after the worktree directory, and to rename its row and agent when the line appears. Run `jh sync` to get the text.

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.26.1/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.26.3/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.26.1/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.26.3/assets/icons/space.svg">
 
 # Jack herds your coding agents.
 
@@ -15,29 +15,29 @@ 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.26.1/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.26.3/assets/icons/space.svg">
 
 <p>
-<img src="https://unpkg.com/jackherd@1.26.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.">
+<img src="https://unpkg.com/jackherd@1.26.3/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.26.1/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.26.3/assets/icons/space.svg">
 </p>
 
-<p><img src="https://unpkg.com/jackherd@1.26.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.26.3/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.26.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.26.3/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.26.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.26.3/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.26.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.26.3/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.26.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.26.3/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.26.1/assets/icons/model.svg" width="24" height="34" align="middle" alt=""> <b>The right model for each phase.</b><br>Every phase names its model: the stronger one where a mistake is expensive (data, security, a migration), the cheaper one for the rest. Lanes start on it, and a hook refuses to start a phase's subagent on a weaker one.</p>
+<p><img src="https://unpkg.com/jackherd@1.26.3/assets/icons/model.svg" width="24" height="34" align="middle" alt=""> <b>The right model for each phase.</b><br>Every phase names its model: the stronger one where a mistake is expensive (data, security, a migration), the cheaper one for the rest. Lanes start on it, and a hook refuses to start a phase's subagent on a weaker one.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.26.1/assets/icons/bowl.svg" width="24" height="34" align="middle" alt=""> <b>A crash or a full context doesn't cost you the work.</b><br>Plan, board and a hand-over file hold the state, not the chat: the next session picks up where the last one stopped.</p>
+<p><img src="https://unpkg.com/jackherd@1.26.3/assets/icons/bowl.svg" width="24" height="34" align="middle" alt=""> <b>A crash or a full context doesn't cost you the work.</b><br>Plan, board and a hand-over file hold the state, not the chat: the next session picks up where the last one stopped.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.26.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.26.1/assets/icons/space.svg"></p>
+<p><img src="https://unpkg.com/jackherd@1.26.3/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.26.3/assets/icons/space.svg"></p>
 
 ## Quickstart
 
@@ -68,22 +68,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.26.1/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.26.3/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.26.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.">
+<img src="https://unpkg.com/jackherd@1.26.3/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.26.1/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.26.3/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.26.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.">
+<img src="https://unpkg.com/jackherd@1.26.3/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 |
 | --- | --- | --- |
@@ -118,7 +118,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, and under each phase heading one sentence on what is different afterwards and for whom. 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.26.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.">
+<img src="https://unpkg.com/jackherd@1.26.3/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/dist/config.d.ts

@@ -122,6 +122,7 @@ declare const jackherdConfigSchema: z.ZodObject<{
     }, z.core.$strict>>;
     lanes: z.ZodPrefault<z.ZodObject<{
         copy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        disposable: z.ZodDefault<z.ZodArray<z.ZodString>>;
         lockFile: z.ZodOptional<z.ZodString>;
         minFreeGb: z.ZodOptional<z.ZodNumber>;
         basePort: z.ZodOptional<z.ZodNumber>;

package/dist/config.js

@@ -747,6 +747,8 @@ var jackherdConfigSchema = z3.strictObject({
   lanes: z3.strictObject({
     /** Untracked files copied into every new worktree; empty means the files `.worktreeinclude` lists. */
     copy: z3.array(laneCopyPath).default([]),
+    /** Ignored paths `jh lane close` deletes with a worktree without asking, in `.gitignore` syntax (`apps/web/tmp`); a pattern without a slash matches at any depth. Everything else ignored still refuses the close. */
+    disposable: z3.array(laneCopyPath).default([]),
     /** The dependency lock file a rebase takes from the base branch and regenerates, never merges by hand; detected from the repository when left out. */
     lockFile: lockFilePath.optional(),
     /** Free gigabytes the disk must hold before `jh lane space` lets a new lane install its dependencies; 5 when left out. */

package/herdr-plugin/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "crossdelta.jackherd"
 name = "jackherd"
-version = "1.26.1"
+version = "1.26.3"
 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.26.1}"
+JACKHERD_VERSION="${JACKHERD_VERSION:-1.26.3}"
 
 JACKHERD_PACKAGE='jackherd'
 # Test seam: the terminal the wizard asks its questions on.

package/kit/workflow/skills/orchestrate/references/close-lane.md

@@ -4,16 +4,16 @@ Read when a lane's status line says `plan finished` and names `jh lane close <la
 or when the user names a lane to close. Run both commands from the main checkout.
 
 1. `jh lane close <lane> --dry-run` checks and lists the steps; it changes nothing. It proves nothing is lost: a
-   merged PR whose tree equals the branch (`git diff <branch-head> <merge-commit>` empty; a squash merge leaves the
-   branch unmerged), no file that removing the worktree would delete, no agent at work in it. A refusal changes
+   merged PR whose tree equals the branch (`git diff <branch-head> <merge-commit>` empty), no file that removing the worktree would delete (dependencies, build output and `lanes.disposable` paths go with it; `.claude/handover/` is
+   copied to `.claude/handover/closed/` first), no agent at work in it. A refusal changes
    nothing: resolve each reason it prints (a named file goes to the user first, a working agent is waited for, a lock
-   is lifted once its session ended, an unmerged branch is not closed) and repeat until it exits 0.
-   A worktree on no branch closes when its head is on the base branch and only staged plan changes the base holds are left.
+   is lifted once its session ended) and repeat until it exits 0.
+   A worktree on no branch closes when its head is on the base branch and only staged plan changes remain.
    Handed-over service: [`backend.md`](backend.md).
-2. `jh lane close <lane>` Run it without asking the user; its checks are the safeguard. It repeats the step 1 checks (resolve a refusal as in step 1) and runs the listed steps, one line each. After a failure,
+2. `jh lane close <lane>` Run it without asking the user; its checks are the safeguard. It repeats the step 1 checks and runs the listed steps, one line each. After a failure,
    run it again: with the worktree gone and the branch left, `jh lane close <lane> --branch <branch>` finishes the
-   branch and the board; a lane closed in full says so and changes nothing.
+   branch and the board; a lane closed in full says so.
 3. The command leaves the rows marked `{{kit.word.laneClosed}} <date>` and the `{{kit.heading.history}}` row as a
    change in the main checkout's board, which the herd shows at once. It reaches `{{kit.baseBranch}}` bundled (§ 4), the
-   marked rows in the same documentation PR as the history entry. Done when the board shows the marks and the history row. If `git ls-remote --heads origin <branch>` still lists the
-   branch, ask the user before deleting it.
+   marked rows in the same documentation PR as the history entry. Done when the board shows the marks and the history row. The command deletes the branch on origin itself when it still
+   holds the merged head; otherwise it says why it stays.

package/kit/workflow/skills/orchestrate/references/lane-session.md

@@ -25,4 +25,4 @@ A lane started before this skill, or a session to resume:
 `herdr worktree open --path <worktree> --label "<lane> :<port>" --no-focus`, then in its pane
 `claude --resume <session-id>`. Move a lane only between phases, when it is `done` or `idle`.
 
-Name the lane after the worktree directory; on `lane <name> not watched`, rename its row and agent to the `<dir>` the line names.
+The watcher places a lane by its agent's cwd; `lane <name> not watched` means ambiguous: keep one `<name>` agent, in its own worktree.

package/package.json

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

package/schemas/jackherd.schema.json

@@ -147,6 +147,14 @@
             "pattern": "^(?![/-])(?!(?:.*\\/)?\\.\\.(?:\\/|$))[^'\\x00-\\x1f\\x7f]+$"
           }
         },
+        "disposable": {
+          "default": [],
+          "type": "array",
+          "items": {
+            "type": "string",
+            "pattern": "^(?![/-])(?!(?:.*\\/)?\\.\\.(?:\\/|$))[^'\\x00-\\x1f\\x7f]+$"
+          }
+        },
         "lockFile": {
           "type": "string",
           "pattern": "^(?![/-])(?!(?:.*\\/)?\\.\\.(?:\\/|$))[A-Za-z0-9._/-]+$"

package/src/brief/lane-facts.ts

@@ -1,10 +1,11 @@
 import { existsSync, readFileSync } from 'node:fs'
 import { dirname, join, relative } from 'node:path'
 import { parseSprintLanes, resolvePlanPath, type SprintLane } from '../plan-format'
+import { settingsPlacingLanes } from '../plans/lane-worktrees'
 import { type QuestionRecord } from '../plans/question-records'
 import { type SentFileRecord, sentLaneOf } from '../plans/sent-files'
-import { type PlansSettings } from '../plans/settings'
-import { laneDirectoryOf } from '../plans/unlisted-lanes'
+import { type PlansSettings, worktreeOf } from '../plans/settings'
+import { type LaneWorktrees, laneOfCwd } from '../plans/unlisted-lanes'
 import { readWaitingRecords } from '../plans/waiting-records'
 import { isStillWaiting } from '../plans/waiting-window'
 import type { LaneFacts } from './lane-brief'
@@ -14,8 +15,8 @@ const planHrefOf = ({ steps }: SprintLane): string | null =>
   steps.filter((step) => step.planHref !== null).at(-1)?.planHref ?? null
 
 /** The plan file as the lane's worktree has it (it ticks and writes the head there), else the main checkout's copy. */
-const planTextOf = (root: string, worktrees: string, lane: string, planPath: string): string | null => {
-  const candidates = [join(worktrees, lane, planPath), join(root, planPath)]
+const planTextOf = (root: string, worktree: string, planPath: string): string | null => {
+  const candidates = [join(worktree, planPath), join(root, planPath)]
   const found = candidates.find((path) => existsSync(path))
   return found === undefined ? null : readFileSync(found, 'utf8')
 }
@@ -25,10 +26,11 @@ const openQuestionsOf = (
   lane: string,
   worktreeDirectory: string,
   now: number,
+  placed: LaneWorktrees,
 ): number =>
   records.filter(
     ({ closedAt, askedAt, cwd }) =>
-      isStillWaiting(closedAt, askedAt, now) && laneDirectoryOf(cwd, worktreeDirectory) === lane,
+      isStillWaiting(closedAt, askedAt, now) && laneOfCwd(cwd, worktreeDirectory, placed) === lane,
   ).length
 
 const openSendsOf = (
@@ -36,9 +38,11 @@ const openSendsOf = (
   lane: string,
   worktreeDirectory: string,
   now: number,
+  placed: LaneWorktrees,
 ): number =>
   records.filter(
-    (record) => isStillWaiting(record.closedAt, record.sentAt, now) && sentLaneOf(record, worktreeDirectory) === lane,
+    (record) =>
+      isStillWaiting(record.closedAt, record.sentAt, now) && sentLaneOf(record, worktreeDirectory, placed) === lane,
   ).length
 
 /**
@@ -49,16 +53,24 @@ export const laneFactsOf = (root: string, settings: PlansSettings, boardFile: st
   const sprintDirectory = dirname(relative(root, boardFile))
   const worktreeDirectory = join(root, settings.worktreeDirectory)
   const records = readWaitingRecords(root)
-  return parseSprintLanes(readFileSync(boardFile, 'utf8'), settings.boardLanguage)
-    .filter(({ closed }) => !closed)
-    .map((lane) => {
-      const href = planHrefOf(lane)
-      return {
-        name: lane.name,
-        plan:
-          href === null ? null : planTextOf(root, worktreeDirectory, lane.name, resolvePlanPath(sprintDirectory, href)),
-        openQuestions: openQuestionsOf(records.questions, lane.name, worktreeDirectory, now),
-        sentFiles: openSendsOf(records.sent, lane.name, worktreeDirectory, now),
-      }
-    })
+  const lanes = parseSprintLanes(readFileSync(boardFile, 'utf8'), settings.boardLanguage).filter(
+    ({ closed }) => !closed,
+  )
+  const placed = settingsPlacingLanes(
+    root,
+    settings,
+    lanes.map(({ name }) => name),
+  )
+  return lanes.map((lane) => {
+    const href = planHrefOf(lane)
+    return {
+      name: lane.name,
+      plan:
+        href === null
+          ? null
+          : planTextOf(root, worktreeOf(root, placed, lane.name), resolvePlanPath(sprintDirectory, href)),
+      openQuestions: openQuestionsOf(records.questions, lane.name, worktreeDirectory, now, placed.laneWorktrees),
+      sentFiles: openSendsOf(records.sent, lane.name, worktreeDirectory, now, placed.laneWorktrees),
+    }
+  })
 }

package/src/config/schema.ts

@@ -603,6 +603,8 @@ export const jackherdConfigSchema = z.strictObject({
     .strictObject({
       /** Untracked files copied into every new worktree; empty means the files `.worktreeinclude` lists. */
       copy: z.array(laneCopyPath).default([]),
+      /** Ignored paths `jh lane close` deletes with a worktree without asking, in `.gitignore` syntax (`apps/web/tmp`); a pattern without a slash matches at any depth. Everything else ignored still refuses the close. */
+      disposable: z.array(laneCopyPath).default([]),
       /** The dependency lock file a rebase takes from the base branch and regenerates, never merges by hand; detected from the repository when left out. */
       lockFile: lockFilePath.optional(),
       /** Free gigabytes the disk must hold before `jh lane space` lets a new lane install its dependencies; 5 when left out. */

package/src/context/command.ts

@@ -2,6 +2,7 @@ import { homedir } from 'node:os'
 import { basename, join } from 'node:path'
 import { CLAUDE_DIRECTORY } from '../claude/paths'
 import { mainCheckout, worktreeRoot } from '../plans/git'
+import { settingsPlacingLanes } from '../plans/lane-worktrees'
 import { type PlansSettings, readSettings, worktreeOf } from '../plans/settings'
 import { type LaneAgent, laneStatusSourceFor } from '../terminal'
 import { AUTO_COMPACT_ENV, autoCompactWindow, compactsBeforeAlertNote, readClaudeSettings } from './auto-compact'
@@ -96,7 +97,8 @@ export const run = async (args: string[]): Promise<number> => {
     const options = parseContextOptions(args)
     const root = mainCheckout(process.cwd())
     const worktree = worktreeRoot(process.cwd())
-    const settings = readSettings([worktree, root])
+    const read = readSettings([worktree, root])
+    const settings = options.lane ? settingsPlacingLanes(root, read, [options.lane]) : read
     if (options.usage) {
       printUsage(options, settings, root, worktree)
       return 0

package/src/lane/close-check.ts

@@ -27,8 +27,9 @@ export type StatusEntry = { code: string; path: string }
 /**
  * What git, GitHub and the terminal answered about one lane, gathered before anything is removed. `treeDiff` lists the
  * paths in which the branch head differs from the merge commit; `status` holds the worktree's status with ignored
- * files (`statusEntriesOf`); `setupFiles` the patterns of the lane setup's copy list; `handoverEntries` every
- * entry of the worktree's handover directory, which git shows only as the directory.
+ * files (`statusEntriesOf`); `setupFiles` the patterns of the lane setup's copy list; `disposablePaths` the patterns
+ * of ignored paths the project lets a close delete (`lanes.disposable`); `handoverEntries` every entry of the
+ * worktree's handover directory, which git shows only as the directory and which the close archives.
  */
 export type CloseFacts = {
   lane: string
@@ -42,7 +43,10 @@ export type CloseFacts = {
   treeDiff: readonly string[]
   status: readonly StatusEntry[]
   setupFiles: readonly string[]
+  disposablePaths: readonly string[]
   handoverEntries: readonly string[]
+  /** The commit the branch points to on origin, read live; null when the branch is gone there or none is named. */
+  remoteHead: string | null
   /** Whether the head of a worktree on no branch is an ancestor of the base branch on the remote. */
   headOnBase: boolean
   /** The staged paths of a worktree on no branch that the base branch on the remote holds with the same content. */
@@ -74,6 +78,7 @@ const BUILD_OUTPUT = [
 /** Build output only as a directory entry: a package's `bin/` that an ignore rule hides as a whole. */
 const BUILD_OUTPUT_DIRECTORY_ENTRIES = [new Bun.Glob('packages/*/bin')]
 const HANDOVER = claudePath(HANDOVER_DIRECTORY)
+const SHORT_COMMIT_LENGTH = 9
 
 /** A change that is staged and nothing more: the worktree file equals the index. */
 const isStagedOnly = (code: string): boolean =>
@@ -81,22 +86,27 @@ const isStagedOnly = (code: string): boolean =>
 
 const withoutSlashes = (path: string): string => path.replace(/^\/+|\/+$/g, '')
 
-const isHandoverDirectory = (path: string): boolean => withoutSlashes(path) === HANDOVER
+/** The handover directory or anything in it: the close archives it, so removing the worktree loses none of it. */
+const isHandoverPath = (path: string): boolean => {
+  const target = withoutSlashes(path)
+  return target === HANDOVER || target.startsWith(`${HANDOVER}/`)
+}
 
 /** The patterns of a `.gitignore`-style list that name files; comments, blanks and negations name none. */
 const patternsOf = (lines: readonly string[]): string[] =>
   lines.map((line) => line.trim()).filter((line) => line !== '' && !line.startsWith('#') && !line.startsWith('!'))
 
 /**
- * Whether `path` (relative to the worktree, a directory with its trailing slash) is one the lane setup copies in: a
- * pattern with an inner slash is anchored at the root, one without matches the name at any depth, as in `.gitignore`.
+ * Whether `path` (relative to the worktree, a directory with its trailing slash) is named by a `.gitignore`-style
+ * list, or lies in a directory it names: a pattern with an inner slash is anchored at the root, one without matches
+ * the name at any depth.
  */
-export const isSetupFile = (path: string, setupFiles: readonly string[]): boolean => {
+export const matchesPatterns = (path: string, patterns: readonly string[]): boolean => {
   const target = withoutSlashes(path)
-  return patternsOf(setupFiles).some((pattern) => {
+  return patternsOf(patterns).some((pattern) => {
     const bare = withoutSlashes(pattern)
     const glob = bare.includes('/') ? bare : `**/${bare}`
-    return new Bun.Glob(glob).match(target) || new Bun.Glob(bare).match(target)
+    return [glob, bare, `${glob}/**`].some((candidate) => new Bun.Glob(candidate).match(target))
   })
 }
 
@@ -134,25 +144,51 @@ export const isBuildOutput = (path: string): boolean => {
 
 /**
  * The paths removing the worktree would delete for good: every tracked change and untracked file, and every ignored
- * path except dependencies (`node_modules` at any depth), the setup files, build output and the handover directory.
+ * path except dependencies (`node_modules` at any depth), the setup files, the project's disposable paths and build
+ * output. The handover directory is no loss either: the close archives it first.
  */
 export const lostPathsOf = (
   status: readonly StatusEntry[],
   setupFiles: readonly string[],
   baseHeldPaths: readonly string[] = [],
+  disposablePaths: readonly string[] = [],
 ): string[] => {
   const kept = (path: string) =>
-    isDependencyPath(path) || isSetupFile(path, setupFiles) || isBuildOutput(path) || isHandoverDirectory(path)
+    isDependencyPath(path) ||
+    matchesPatterns(path, setupFiles) ||
+    matchesPatterns(path, disposablePaths) ||
+    isBuildOutput(path)
   const held = ({ code, path }: StatusEntry) => isStagedOnly(code) && baseHeldPaths.includes(path)
   return status
+    .filter(({ path }) => !isHandoverPath(path))
     .filter((entry) => (entry.code !== IGNORED_CODE || !kept(entry.path)) && !held(entry))
     .map(({ path }) => path)
 }
 
-/** The lost paths and the entries of the handover directory, each once: the directory stands for all of them. */
-const deletedPathsOf = ({ status, setupFiles, handoverEntries, baseHeldPaths }: CloseFacts): string[] => [
-  ...new Set([...lostPathsOf(status, setupFiles, baseHeldPaths), ...handoverEntries]),
-]
+const deletedPathsOf = ({ status, setupFiles, baseHeldPaths, disposablePaths }: CloseFacts): string[] =>
+  lostPathsOf(status, setupFiles, baseHeldPaths, disposablePaths)
+
+/** What closing does with the lane's branch on origin: delete it at the head the check saw, leave it with the reason, or nothing to do. */
+export type RemoteBranchPlan =
+  | { kind: 'delete'; branch: string; head: string }
+  | { kind: 'keep'; branch: string; reason: string }
+  | { kind: 'none' }
+
+/**
+ * The branch on origin goes only when it points to the head of the merged pull request, so nothing pushed after the
+ * merge is lost; otherwise it stays and the plan says why.
+ */
+export const remoteBranchPlanOf = ({ branch, pullRequest, remoteHead }: CloseFacts): RemoteBranchPlan => {
+  if (branch === null || remoteHead === null) return { kind: 'none' }
+  if (pullRequest === null) return { kind: 'keep', branch, reason: 'it has no merged pull request' }
+  if (remoteHead !== pullRequest.headCommit)
+    return {
+      kind: 'keep',
+      branch,
+      reason: `origin has ${remoteHead.slice(0, SHORT_COMMIT_LENGTH)}, not the merged head ${pullRequest.headCommit.slice(0, SHORT_COMMIT_LENGTH)} of #${pullRequest.number}`,
+    }
+  return { kind: 'delete', branch, head: remoteHead }
+}
 
 /** A lane the board marks cleaned up already may still have its worktree left over; only a lane it never named is refused. */
 const boardRefusals = ({ lane, boardLane }: CloseFacts): string[] =>
@@ -183,7 +219,7 @@ const lockRefusals = ({ lane, locked }: CloseFacts): string[] =>
  * Every reason not to close the lane, all at once; empty when nothing would be lost. Closing needs an open board row,
  * the worktree on a branch whose newest merged pull request left the same tree on the base (a squash merge leaves the
  * branch unmerged in git's eyes, so the trees are compared), nothing in the worktree beyond dependencies, the setup
- * files and build output (`isBuildOutput`), an empty handover directory, an agent that is gone or rests, and no lock
+ * files, the project's disposable paths and build output (`isBuildOutput`), an agent that is gone or rests, and no lock
  * on the worktree (a Claude Code session may still hold it).
  */
 export const closeRefusals = (facts: CloseFacts): string[] => {

package/src/lane/close-command.ts

@@ -1,10 +1,11 @@
-import { existsSync, readdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs'
+import { cpSync, existsSync, readdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs'
 import { join, relative, resolve } from 'node:path'
 import { claudePath, HANDOVER_DIRECTORY } from '../claude/paths'
 import { TERMINAL_ADAPTER } from '../config'
 import { terminalSafe } from '../plan-format/terminal-text'
 import { boardFor } from '../plans/board-pick'
 import { commitOf, mainCheckout, worktreeRoot } from '../plans/git'
+import { settingsPlacingBoardLanes } from '../plans/lane-worktrees'
 import { type PlansSettings, readSettings, worktreeOf } from '../plans/settings'
 import { asksForHelp } from '../preview/options'
 import { laneStatusSourceFor } from '../terminal'
@@ -20,6 +21,7 @@ import {
   baseHeldPathsOf,
   mergedPullRequestOf,
   openWorkspaceOf,
+  remoteHeadOf,
   stagedPlanPathsOf,
   type WorktreeEntry,
   worktreeEntryOf,
@@ -179,19 +181,29 @@ const workspaceOf = (context: CloseContext): string | null =>
 const absentWorktreeFactsOf = (context: CloseContext, branch: string | null): Promise<WorktreeFacts> | WorktreeFacts =>
   branch === null ? ABSENT_WORKTREE : branchFactsOf(context, branch)
 
+/** The commit the branch points to on origin, asked live; null when there is no branch to ask for or origin lists none. */
+const remoteHeadFor = (context: CloseContext, branch: string | null): string | null =>
+  branch === null
+    ? null
+    : remoteHeadOf(runGit(context.root, ['ls-remote', '--heads', 'origin', `${BRANCH_REF}${branch}`]), branch)
+
 /** What git, GitHub and the terminal say about the lane now; throws when one of them cannot be asked. */
 const surveyOf = async (lane: string, branch: string | null, context: CloseContext): Promise<CloseSurvey> => {
   const entry = worktreeEntryOf(runGit(context.root, ['worktree', 'list', '--porcelain']), context.worktree)
   const present = entry !== null && existsSync(context.worktree)
-  const facts: CloseFacts = {
+  const facts: Omit<CloseFacts, 'remoteHead'> = {
     lane,
     boardLane: boardLaneOf(readFileSync(context.boardFile, 'utf8'), lane, context.settings.boardLanguage),
     setupFiles: setupFilesOf(context.root),
+    disposablePaths: context.settings.disposablePaths,
     ...agentFactsOf(laneStatusSourceFor(context.settings.adapter).listAgents(), lane, context.worktree),
     runsInside: realPath(worktreeRoot(context.cwd)) === realPath(context.worktree),
     ...(present ? await worktreeFactsOf(context, entry) : await absentWorktreeFactsOf(context, branch)),
   }
-  return { facts, workspace: present ? workspaceOf(context) : null }
+  return {
+    facts: { ...facts, remoteHead: remoteHeadFor(context, facts.branch) },
+    workspace: present ? workspaceOf(context) : null,
+  }
 }
 
 const sleep = (ms: number): Promise<void> => new Promise((done) => setTimeout(done, ms))
@@ -211,7 +223,14 @@ const exitAgentIn =
     throw new Error(`the agent in pane ${pane} still runs after ${EXIT_WAIT_MS / 1000} s`)
   }
 
-/** Git removes the worktree and refuses on any change itself; herdr then only closes the emptied workspace. */
+/** Copies the handover directory of the worktree below the main checkout; throws when the copy fails, so nothing is removed after it. */
+const archiveHandoverIn =
+  (context: CloseContext) =>
+  (worktree: string, destination: string): void => {
+    cpSync(join(worktree, claudePath(HANDOVER_DIRECTORY)), join(context.root, destination), { recursive: true })
+  }
+
+/** Git removes the worktree and refuses on any change itself (ignored files go with it, never needing `--force`); herdr then only closes the emptied workspace. */
 const removeWorktreeIn =
   (context: CloseContext) =>
   (worktree: string, workspace: string | null): void => {
@@ -220,6 +239,17 @@ const removeWorktreeIn =
   }
 
 /** Deletes the branch only while it points to `head`; git refuses when it moved since the check. */
+const deleteRemoteBranchIn =
+  (context: CloseContext) =>
+  (branch: string, head: string): void => {
+    runGit(context.root, [
+      'push',
+      'origin',
+      `--force-with-lease=${BRANCH_REF}${branch}:${head}`,
+      `:${BRANCH_REF}${branch}`,
+    ])
+  }
+
 const deleteBranchIn =
   (context: CloseContext) =>
   (branch: string, head: string): void => {
@@ -229,7 +259,9 @@ const deleteBranchIn =
 const portsFor = (lane: string, branch: string | null, context: CloseContext): ClosePorts => ({
   survey: () => surveyOf(lane, branch, context),
   exitAgent: exitAgentIn(context),
+  archiveHandover: archiveHandoverIn(context),
   removeWorktree: removeWorktreeIn(context),
+  deleteRemoteBranch: deleteRemoteBranchIn(context),
   deleteBranch: deleteBranchIn(context),
   readBoard: () => readFileSync(context.boardFile, 'utf8'),
   writeBoard: (text) => writeFileSync(context.boardFile, text),
@@ -240,16 +272,17 @@ const portsFor = (lane: string, branch: string | null, context: CloseContext): C
 /** The main checkout, its settings, the lane's worktree from those settings, and the board, with the pick's notice. */
 const contextOf = (options: CloseOptions, cwd: string): { context: CloseContext; notice: string | null } => {
   const root = mainCheckout(cwd)
-  const settings = readSettings([root, worktreeRoot(cwd)])
+  const settings = readSettings([worktreeRoot(cwd), root])
   const boardPath = options.boardPath === null ? null : resolve(cwd, options.boardPath)
   const board = boardFor(boardPath, [root], settings, () => [options.lane])
-  const worktree = worktreeOf(root, settings, options.lane)
-  return { context: { root, cwd, settings, worktree, boardFile: board.file }, notice: board.notice }
+  const placed = settingsPlacingBoardLanes(root, settings, board.file, options.lane)
+  const worktree = worktreeOf(root, placed, options.lane)
+  return { context: { root, cwd, settings: placed, worktree, boardFile: board.file }, notice: board.notice }
 }
 
 /**
  * `jh lane close <lane> [--dry-run] [--board <board.md>]`: closes a lane in one run once nothing would be lost, see
- * `closeLane`. The worktree's path comes from the settings and the lane's name, never from a reply. Exit 0 closed or
+ * `closeLane`. The worktree's path comes from the lane's name, or from the one existing directory below the worktree directory that the lane's agent runs in when no directory carries the name; never from a reply. Exit 0 closed or
  * dry run, 1 refused or failed.
  */
 export const run = async (args: string[], cwd: string = process.cwd()): Promise<number> => {

package/src/lane/close-survey.ts

@@ -62,6 +62,15 @@ export const mergedPullRequestOf = (
   return merged.sort((left, right) => right.number - left.number)[0] ?? null
 }
 
+/** The commit `branch` points to in the output of `git ls-remote --heads origin`; null when the remote lists no such branch. */
+export const remoteHeadOf = (lsRemote: string, branch: string): string | null => {
+  const entry = lsRemote
+    .split('\n')
+    .map((line) => line.split('\t'))
+    .find(([, ref]) => ref === `${BRANCH_REF}${branch}`)
+  return entry !== undefined && isObjectId(entry[0]) ? entry[0] : null
+}
+
 const isInside = (cwd: string | null, worktree: string): boolean =>
   cwd !== null && (cwd === worktree || cwd.startsWith(`${worktree}${sep}`))