jackherd 1.23.0 → 1.23.2

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 What changed for people who use jackherd, newest first.
 
+## 1.23.2
+
+- **After a reboot the coordinator is found without its name, and the herd comes back.** herdr keeps no name given with `herdr agent rename` over a restore, so `jh resume` found no coordinator and sent nothing. The watcher's resume record now also keeps the coordinator's agent session id and pane id, and the lanes' model columns; `jh resume` finds the coordinator by the session id (else the pane id) in the main checkout, sets the name again and logs it. Records of older versions work as before. Repositories are resumed at the same time, so one missing coordinator no longer holds up the others. herdr cannot tell which model a restored lane runs (it comes back without `--model`), so the log names each interrupted lane with its board model and the coordinator's line asks it to check those lanes against `lane-session.md`. `herd --ensure` leaves out a pane whose `process-info` fails (an old shell in a deleted directory) with one line, instead of failing for every lane.
+
+## 1.23.1
+
+- **A lane with uncommitted work can rebase after a merge.** The orchestrate skill (§ 5 and § 6) let a lane work uncommitted until its PR was ready and also told every lane to rebase after each merge; Git rebases no dirty tree and `git stash` is shared between worktrees. Such a lane now commits locally with `-F` (amended in later rounds), rebases, and runs the install command; push and PR still wait for the PR approval. Run `jh sync` to get the skill text.
+
 ## 1.23.0
 
 - **`jh lane dev <lane>` starts a lane's dev server in one call.** It splits a pane beside the lane's agent, labels it `<lane> dev :<port>`, runs `PORT=<port> <command>` there and prints one line (pane, label, port, command). The port is `--port` or the port column of the lane's board row (`--board <board.md>` names the board), and a port something listens on is refused. A pane with that label in the lane's tab is reported and left alone. The command is the new `lanes.devCommand` in `.jackherd/config.json`, with `{port}` and `{filter}` (`--filter <package>`) filled in; without it the call refuses and names the key. The coordinator no longer chains `herdr pane split`, `rename` and `run`, which the merge guard asked about; `jh lane dev` passes it like any other `jh` call. Run `jh sync` to get the skill 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.23.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.23.2/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.23.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.23.2/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.23.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.23.2/assets/icons/space.svg">
 
 <p>
-<img src="https://unpkg.com/jackherd@1.23.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.23.2/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.23.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.23.2/assets/icons/space.svg">
 </p>
 
-<p><img src="https://unpkg.com/jackherd@1.23.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.23.2/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.23.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.23.2/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.23.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.23.2/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.23.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.23.2/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.23.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.23.2/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.23.0/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.23.2/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.23.0/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.23.2/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.23.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.23.0/assets/icons/space.svg"></p>
+<p><img src="https://unpkg.com/jackherd@1.23.2/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.23.2/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.23.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.23.2/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.23.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.23.2/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.23.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.23.2/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.23.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.23.2/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. 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.23.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.23.2/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.23.0"
+version = "1.23.2"
 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.23.0}"
+JACKHERD_VERSION="${JACKHERD_VERSION:-1.23.2}"
 
 JACKHERD_PACKAGE='jackherd'
 # Test seam: the terminal the wizard asks its questions on.

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

@@ -268,7 +268,7 @@ before you open it.
 
 ## 5. Commits, push, PR
 
-**One approval per PR, not per commit.** A lane works uncommitted until its PR is ready, then asks
+**One approval per PR, not per commit.** A lane works uncommitted until its PR is ready (the local commit before a rebase, § 6, aside), then asks
 once; that approval covers the commits, the push and opening the PR. The user merges every PR, unless the
 project supplement names PRs Jack may merge itself (approval tiers), the user picked the self-merge option
 (step 2), or a standing approval covers the lane's plan. When the user wants a plan's lanes merged without a question for a while, ask for or end one as [`references/standing-approval.md`](references/standing-approval.md) says.
@@ -278,7 +278,8 @@ sits on the one-time option, only for a step on this list:
 
 - under the lane's PR approval: the commit, and the push of the lane's own branch to its own
   remote branch, forced only with `--force-with-lease`
-- the rebase after a merge (§ 6), which needs no approval of its own: `git fetch`,
+- the rebase after a merge (§ 6), which needs no approval of its own: for a lane with uncommitted work first
+  `git commit -F <file>` or `git commit --amend -F <file>` (§ 6); then `git fetch`,
   `git rebase origin/{{kit.baseBranch}}` (`--onto origin/{{kit.baseBranch}} <old PR head>` for a branch over a
   merged PR's), `git checkout --ours {{kit.lanes.lockFile}}`,
   `git add {{kit.lanes.lockFile}}`, `{{kit.command.install}}`, `git rebase --continue`
@@ -342,6 +343,7 @@ the user every time.
   `git rebase origin/{{kit.baseBranch}}`, as two commands, and to re-run before they push the checks the
   watcher's duty line names after `merged #<n>`; whenever in doubt, all of them. A `{{kit.lanes.lockFile}}` conflict is never resolved by hand: take the base branch's
   (`git checkout --ours {{kit.lanes.lockFile}}` during a rebase), run `{{kit.command.install}}`, continue.
+- **A lane with uncommitted work takes the same rebase after each merge**, committing locally first with `-F` (one commit, amended in later rounds and at the PR approval), since Git rebases no dirty tree and `git stash` is shared between worktrees; its push and PR wait for the PR approval (§ 5), and its dev server runs on the current base branch.
 - Merge order is the board's. A PR ready early waits for its turn, its lane goes on (§ 2); say so.
 - **The documentation PR of § 2 step 0 merges first**, before any lane PR that started from it; then clean up
   as in [`references/plan-commit.md`](references/plan-commit.md).

package/package.json

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

package/src/plans/ensure-panes.ts

@@ -19,14 +19,14 @@ import {
   splitPaneOf,
   viewCommandOf,
   withAgentPanes,
+  withForeground,
 } from './plan-panes'
 import type { PlansSettings } from './settings'
 
-const panesWithForeground = (agentPanes: readonly string[]): PaneState[] =>
-  withAgentPanes(paneListOf(runHerdr(['pane', 'list'])), agentPanes).map((each) => ({
-    ...each,
-    foreground: foregroundOf(runHerdr(['pane', 'process-info', '--pane', each.pane])),
-  }))
+const panesWithForeground = (agentPanes: readonly string[]): { panes: PaneState[]; notes: string[] } =>
+  withForeground(withAgentPanes(paneListOf(runHerdr(['pane', 'list'])), agentPanes), (pane) =>
+    foregroundOf(runHerdr(['pane', 'process-info', '--pane', pane])),
+  )
 
 /** The board's lanes that have a worktree, closed ones left out. */
 const lanesOf = (root: string, settings: PlansSettings, boardFile: string) =>
@@ -72,7 +72,7 @@ export const ensurePlanPaneRun = (
 ): { lines: string[]; exitCode: EnsureExit } => {
   const agents = runHerdr(['agent', 'list'])
   const listed = parseAgentList(agents)
-  const panes = panesWithForeground(agentPanesOf(agents))
+  const { panes, notes: skipped } = panesWithForeground(agentPanesOf(agents))
   const coordinatorName = resolveCoordinatorName(
     basename(root),
     listed.map((agent) => agent.name),
@@ -91,7 +91,7 @@ export const ensurePlanPaneRun = (
     command: (lane) => viewCommandOf(process.argv, lane),
     missingCoordinator: missingCoordinatorNote(panes, root, coordinatorName),
   })
-  return { lines: [...actions.map(apply), ...notes], exitCode: ensureExitOf(panes, coordinator) }
+  return { lines: [...skipped, ...actions.map(apply), ...notes], exitCode: ensureExitOf(panes, coordinator) }
 }
 
 /** The lines of `ensurePlanPaneRun`, for a caller that brings the panes back without an exit code (the watcher). */

package/src/plans/plan-panes.ts

@@ -1,4 +1,5 @@
 import { basename } from 'node:path'
+import { errorText } from './error-text'
 import { HERD_COMMAND, HERD_COMMAND_WORDS } from './herd-command'
 
 /**
@@ -83,6 +84,27 @@ export const withAgentPanes = <Pane extends { pane: string; agent: boolean }>(
   agentPanes: readonly string[],
 ): Pane[] => panes.map((each) => (agentPanes.includes(each.pane) ? { ...each, agent: true } : each))
 
+/**
+ * The panes with their foreground from `readForeground`; a pane it throws for is left out with one note. herdr lists
+ * panes it cannot answer for (old shells whose directory is gone answer `pane_not_found`), and one of them must not
+ * keep the herd from the others.
+ */
+export const withForeground = (
+  panes: readonly Omit<PaneState, 'foreground'>[],
+  readForeground: (pane: string) => string[][],
+): { panes: PaneState[]; notes: string[] } => {
+  const kept: PaneState[] = []
+  const notes: string[] = []
+  for (const each of panes) {
+    try {
+      kept.push({ ...each, foreground: readForeground(each.pane) })
+    } catch (error) {
+      notes.push(`${each.pane}: no process info, left out (${errorText(error)})`)
+    }
+  }
+  return { panes: kept, notes }
+}
+
 const isArgv = (value: unknown): value is string[] =>
   Array.isArray(value) && value.every((arg) => typeof arg === 'string')
 

package/src/resume/command.ts

@@ -4,7 +4,17 @@ import { errorText } from '../plans/error-text'
 import type { PlanLanguage } from '../vocabulary'
 import { type ResumeDecision, resumeDecision } from './decision'
 import { type ResumeRecord, resumedRecord } from './record'
-import { type AgentPane, type Streak, steadyTarget, TARGET_MISS, type TargetMissed, targetFor } from './targets'
+import {
+  type AgentIdentity,
+  type AgentPane,
+  type Streak,
+  steadyTarget,
+  TARGET_MISS,
+  TARGET_VIA,
+  type TargetMissed,
+  type TargetVia,
+  targetFor,
+} from './targets'
 import { resumeTexts } from './texts'
 
 type Limits = { attempts: number; intervalMs: number }
@@ -34,6 +44,8 @@ export type ResumePorts = {
   settingsOf: (root: string) => { language: PlanLanguage; worktreeDirectory: string }
   /** herdr's agent panes; throws with herdr's error when it does not answer. */
   agentPanes: () => AgentPane[]
+  /** Gives the agent in `pane` the herdr name `name` again (`herdr agent rename`); throws with herdr's error. */
+  rename: (pane: string, name: string) => void
   send: SendPorts
   sleep: (ms: number) => Promise<void>
   log: (root: string, message: string) => void
@@ -42,7 +54,7 @@ export type ResumePorts = {
 
 type Resume = Extract<ResumeDecision, { kind: 'resume' }>
 
-type Recipient = { name: string; directory: string }
+type Recipient = { name: string; directory: string; identity?: AgentIdentity }
 
 type Search = { found: Map<Recipient, string>; missed: Map<Recipient, TargetMissed> }
 
@@ -78,20 +90,23 @@ const awaitTargets = async (
   root: string,
   recipients: readonly Recipient[],
   limits: Limits,
-  onFound: (target: string) => Promise<void>,
+  onFound: (target: string, via: TargetVia) => Promise<void>,
 ): Promise<Search> => {
   const search: Search = { found: new Map(), missed: new Map() }
   const streaks = new Map<Recipient, Streak>()
   for (let attempt = 1; search.found.size < recipients.length; attempt++) {
     const panes = pollPanes(ports, root)
     for (const recipient of recipients.filter((each) => !search.found.has(each))) {
-      const steady = steadyTarget(targetFor(panes, recipient.name, recipient.directory), streaks.get(recipient) ?? null)
+      const steady = steadyTarget(
+        targetFor(panes, recipient.name, recipient.directory, recipient.identity),
+        streaks.get(recipient) ?? null,
+      )
       streaks.set(recipient, steady.streak)
       if (steady.target.kind === 'none') search.missed.set(recipient, steady.target)
       else {
         search.found.set(recipient, steady.target.target)
         search.missed.delete(recipient)
-        await onFound(steady.target.target)
+        await onFound(steady.target.target, steady.target.via)
       }
     }
     if (search.found.size === recipients.length || attempt >= limits.attempts) break
@@ -131,10 +146,27 @@ const sendTo = async (ports: ResumePorts, root: string, target: string, text: st
   ports.log(root, (await sendLanePrompt(ports.send, target, text)).line)
 }
 
+/** herdr does not keep a name given by `herdr agent rename` over a restore; a coordinator found without it gets it back. */
+const renameCoordinator = async (ports: ResumePorts, decision: Resume, pane: string, via: TargetVia) => {
+  if (via !== TARGET_VIA.session && via !== TARGET_VIA.pane) return
+  try {
+    ports.rename(pane, decision.coordinator)
+    ports.log(decision.root, `coordinator ${decision.coordinator} found by its ${via} in ${pane}, name set again`)
+  } catch (error) {
+    ports.log(decision.root, `coordinator found by its ${via} in ${pane}, rename failed: ${errorText(error)}`)
+  }
+}
+
 /** The coordinator's target once it is back in the main checkout; null, logged, when it is not within the window. */
 const awaitCoordinator = async (ports: ResumePorts, decision: Resume): Promise<string | null> => {
-  const recipient = { name: decision.coordinator, directory: decision.root }
-  const search = await awaitTargets(ports, decision.root, [recipient], RESUME_LIMITS.coordinator, async () => {})
+  const recipient: Recipient = {
+    name: decision.coordinator,
+    directory: decision.root,
+    ...(decision.coordinatorIdentity ? { identity: decision.coordinatorIdentity } : {}),
+  }
+  const search = await awaitTargets(ports, decision.root, [recipient], RESUME_LIMITS.coordinator, (pane, via) =>
+    renameCoordinator(ports, decision, pane, via),
+  )
   reportMisses(ports, decision.root, search.missed, (name) => `no coordinator ${name}`)
   return search.found.get(recipient) ?? null
 }
@@ -162,7 +194,10 @@ const resumeRepository = async (ports: ResumePorts, path: string, record: Resume
   if (decision.unsafe.length > 0) ports.log(decision.root, `left out, no lane names: ${decision.unsafe.join(', ')}`)
   const coordinator = await awaitCoordinator(ports, decision)
   if (coordinator === null || !marked(ports, path, record)) return
-  const line = texts.coordinatorLine(decision.board, decision.interrupted, decision.blocked)
+  const modelCheck = Object.keys(decision.laneModels)
+  for (const [name, model] of Object.entries(decision.laneModels))
+    ports.log(decision.root, `${name}: restored without --model, board model ${model}; the coordinator checks it`)
+  const line = texts.coordinatorLine(decision.board, decision.interrupted, decision.blocked, modelCheck)
   await sendTo(ports, decision.root, coordinator, line)
   await resumeLanes(ports, decision, worktreeDirectory, texts.laneText)
 }
@@ -178,19 +213,24 @@ const resumeEntry = async (ports: ResumePorts, path: string, record: ResumeRecor
   else await resumeRepository(ports, path, record, decision)
 }
 
-/** Every repository with a record, one after the other; a failure in one is logged and the next goes on. Always 0. */
+const resumeSafely = async (ports: ResumePorts, path: string, record: ResumeRecord | null) => {
+  try {
+    if (record === null) ports.log(path, 'damaged record, read as none')
+    else await resumeEntry(ports, path, record)
+  } catch (error) {
+    ports.log(record?.root ?? path, `failed: ${errorText(error)}`)
+  }
+}
+
+/**
+ * Every repository with a record at once, so one whose coordinator does not come back holds up no other; a failure in
+ * one is logged and the others go on. Every log line starts with its repository. Always 0.
+ */
 export const resumeAll = async (ports: ResumePorts): Promise<number> => {
   try {
     const entries = ports.records()
     if (entries.length === 0) ports.log('-', 'no resume record')
-    for (const { path, record } of entries) {
-      try {
-        if (record === null) ports.log(path, 'damaged record, read as none')
-        else await resumeEntry(ports, path, record)
-      } catch (error) {
-        ports.log(record?.root ?? path, `failed: ${errorText(error)}`)
-      }
-    }
+    await Promise.all(entries.map(({ path, record }) => resumeSafely(ports, path, record)))
   } catch (error) {
     ports.log('-', `cannot read the records: ${errorText(error)}`)
   }

package/src/resume/decision.ts

@@ -1,7 +1,7 @@
 import { isAbsolute, relative, sep } from 'node:path'
 import { AGENT_STATUS, type AgentStatus } from '../terminal/types'
 import { SAFE_LANE_NAME } from '../watch/lane-name'
-import type { ResumeRecord } from './record'
+import type { CoordinatorIdentity, ResumeRecord } from './record'
 
 /** Why `jh resume` leaves a repository alone. */
 export const RESUME_SKIP = {
@@ -45,6 +45,10 @@ export type ResumeDecision =
       interrupted: string[]
       /** The lanes that waited for an answer; only named to the coordinator. */
       blocked: string[]
+      /** What finds the coordinator without its name; null for a record of an older version. */
+      coordinatorIdentity: CoordinatorIdentity | null
+      /** The interrupted lanes with a model column on record, each with that column made printable; only logged. */
+      laneModels: Record<string, string>
       /** Lane names that are no single file name: never sent to, only logged. */
       unsafe: string[]
     }
@@ -65,6 +69,23 @@ const isSafeName = (name: string): boolean => SAFE_LANE_NAME.test(name) && !name
 const lanesWith = (lanes: Record<string, string>, status: AgentStatus): string[] =>
   Object.entries(lanes).flatMap(([name, laneStatus]) => (laneStatus === status && isSafeName(name) ? [name] : []))
 
+const MODEL_TEXT_LIMIT = 60
+
+/** A board cell for the log: printable characters only, so a column cannot break a log line. */
+const printable = (column: string): string =>
+  column
+    .replace(/[^\p{L}\p{N}._/ ,+|-]/gu, '?')
+    .trim()
+    .slice(0, MODEL_TEXT_LIMIT)
+
+const modelsOf = (record: ResumeRecord, lanes: readonly string[]): Record<string, string> =>
+  Object.fromEntries(
+    lanes.flatMap((name) => {
+      const column = record.laneModels?.[name]
+      return column === undefined ? [] : [[name, printable(column)]]
+    }),
+  )
+
 const skip = (reason: ResumeSkip): ResumeDecision => ({ kind: 'none', reason })
 
 /** The reason the record itself gives against a restart, checked before what the system says now. */
@@ -90,12 +111,15 @@ export const resumeDecision = ({ record, now, watcherRunning, boardExists }: Res
   const board = boardInside(record.root, record.board)
   if (board === null) return skip(RESUME_SKIP.unsafeBoard)
   if (!boardExists) return skip(RESUME_SKIP.boardMissing)
+  const interrupted = lanesWith(record.lanes, AGENT_STATUS.working)
   return {
     kind: 'resume',
     root: record.root,
     board,
     coordinator: record.coordinator,
-    interrupted: lanesWith(record.lanes, AGENT_STATUS.working),
+    coordinatorIdentity: record.coordinatorIdentity ?? null,
+    laneModels: modelsOf(record, interrupted),
+    interrupted,
     blocked: lanesWith(record.lanes, AGENT_STATUS.blocked),
     unsafe: Object.keys(record.lanes).filter((name) => !isSafeName(name)),
   }

package/src/resume/keeper.ts

@@ -1,6 +1,15 @@
 import { errorText } from '../plans/error-text'
-import type { LaneSnapshot } from '../watch/lane-watch'
-import { followedRecord, type RecordStart, type ResumeRecord, runningRecord, stoppedRecord } from './record'
+import type { HerdrAgent, LaneSnapshot } from '../watch/lane-watch'
+import {
+  type CoordinatorIdentity,
+  followedRecord,
+  type Observed,
+  type RecordStart,
+  type ResumeRecord,
+  runningRecord,
+  stoppedRecord,
+} from './record'
+import { sessionValueOf } from './targets'
 
 /** The one record file of a repository; `read` gives null for a missing or damaged one. */
 export type RecordStore = {
@@ -15,13 +24,31 @@ export type KeeperPorts = {
 
 /** What the watcher calls: `follow` at every herdr poll, `stop` once on a clean end. */
 export type RecordKeeper = {
-  follow: (lanes: LaneSnapshot, now: number) => void
+  follow: (lanes: LaneSnapshot, now: number, observed?: Observed) => void
   stop: (now: number) => void
 }
 
 export const laneStatusesOf = (snapshot: LaneSnapshot): Record<string, string> =>
   Object.fromEntries(Object.entries(snapshot).map(([name, lane]) => [name, lane.status]))
 
+/**
+ * What identifies the coordinator without its name: the agent herdr lists under `name`, else the unnamed agent in the
+ * watcher's own pane (as `coordinatorTargetOf` finds it). Null when neither is listed.
+ */
+export const coordinatorIdentityOf = (
+  agents: readonly HerdrAgent[],
+  name: string,
+  ownPane: string | undefined,
+): CoordinatorIdentity | null => {
+  const agent =
+    agents.find((each) => each.name === name) ?? agents.find((each) => each.pane_id === ownPane && !each.name)
+  return agent ? { pane: agent.pane_id, session: sessionValueOf(agent.agent_session) } : null
+}
+
+/** Lane → the model column of its board row, from the watcher's last model readings. */
+export const laneModelColumnsOf = (readings: Record<string, { column: string }>): Record<string, string> =>
+  Object.fromEntries(Object.entries(readings).map(([lane, { column }]) => [lane, column]))
+
 /**
  * Keeps the resume record of the watcher in `start.pid` beside its loop: running at the start, saved when a lane status
  * changes or `RESUME_REFRESH_MS` is up, stamped as stopped at a clean end unless a successor holds the file by then (a
@@ -48,8 +75,8 @@ export const keepRecord = (start: RecordStart, now: number, ports: KeeperPorts):
   let current = runningRecord(start, now)
   let unsaved = !attempt(() => ports.store.write(current))
   return {
-    follow: (lanes, at) => {
-      const next = followedRecord(current, laneStatusesOf(lanes), at)
+    follow: (lanes, at, observed) => {
+      const next = followedRecord(current, laneStatusesOf(lanes), at, observed)
       if (next === current && !unsaved) return
       current = next
       unsaved = !attempt(() => ports.store.write(next))

package/src/resume/ports.ts

@@ -88,6 +88,9 @@ export const systemResumePorts = (home: string = homedir()): ResumePorts => {
       return { language: responseLanguage, worktreeDirectory }
     },
     agentPanes: () => resumablePanesOf(herdr(['agent', 'list']), herdr(['pane', 'list'])),
+    rename: (pane, name) => {
+      herdr(['agent', 'rename', pane, name])
+    },
     send: herdrSendPorts(),
     sleep: (ms) => Bun.sleep(ms),
     log,

package/src/resume/record.ts

@@ -9,6 +9,9 @@ export const RESUME_RECORD_VERSION = 1
 /** Below `~/.jackherd/`: the user's own, outside every repository an agent writes to. */
 const RESUME_DIRECTORY = 'resume'
 
+/** The herdr pane and the agent session id of the coordinator; either may be unknown. */
+export type CoordinatorIdentity = { pane: string | null; session: string | null }
+
 /**
  * What the watcher keeps about one repository so `jh resume` can tell a crash from a stop: a record without `stoppedAt`
  * was left by a watcher that never ended cleanly. `lanes` holds each lane's last `agent_status`, `resumedAt` the one
@@ -21,10 +24,18 @@ export type ResumeRecord = {
   board: string
   /** The coordinator's herdr name. */
   coordinator: string
+  /**
+   * What finds the coordinator when herdr restores its pane without the name (`herdr agent rename` does not survive a
+   * restore, the session id and the pane id do). Absent in records of older versions and until the watcher has seen
+   * the coordinator.
+   */
+  coordinatorIdentity?: CoordinatorIdentity
   pid: number
   startedAt: number
   savedAt: number
   lanes: Record<string, string>
+  /** Lane → the model column of its board row as the watcher last read it; absent in older records. */
+  laneModels?: Record<string, string>
   stoppedAt: number | null
   resumedAt: number | null
 }
@@ -41,6 +52,11 @@ const isAbsolutePath = (value: unknown): boolean => typeof value === 'string' &&
 const isLaneStatuses = (value: unknown): boolean =>
   isRecord(value) && Object.values(value).every((status) => typeof status === 'string')
 
+const isStringOrNull = (value: unknown): boolean => value === null || typeof value === 'string'
+
+const isCoordinatorIdentity = (value: unknown): boolean =>
+  isRecord(value) && isStringOrNull(value.pane) && isStringOrNull(value.session)
+
 export const isResumeRecord = (value: unknown): value is ResumeRecord =>
   isRecord(value) &&
   value.version === RESUME_RECORD_VERSION &&
@@ -52,6 +68,8 @@ export const isResumeRecord = (value: unknown): value is ResumeRecord =>
   isTime(value.startedAt) &&
   isTime(value.savedAt) &&
   isLaneStatuses(value.lanes) &&
+  (value.coordinatorIdentity === undefined || isCoordinatorIdentity(value.coordinatorIdentity)) &&
+  (value.laneModels === undefined || isLaneStatuses(value.laneModels)) &&
   'stoppedAt' in value &&
   isTimeOrNull(value.stoppedAt) &&
   'resumedAt' in value &&
@@ -94,6 +112,26 @@ const sameStatuses = (left: Record<string, string>, right: Record<string, string
 export const withLanes = (record: ResumeRecord, lanes: Record<string, string>, now: number): ResumeRecord =>
   sameStatuses(record.lanes, lanes) ? record : { ...record, lanes: { ...lanes }, savedAt: now }
 
+const sameIdentity = (left: CoordinatorIdentity | undefined, right: CoordinatorIdentity): boolean =>
+  left?.pane === right.pane && left?.session === right.session
+
+/** The record with the coordinator's identity; the same object when it is unchanged or unknown (null keeps the stored one). */
+export const withIdentity = (record: ResumeRecord, identity: CoordinatorIdentity | null, now: number): ResumeRecord =>
+  identity === null ||
+  (identity.pane === null && identity.session === null) ||
+  sameIdentity(record.coordinatorIdentity, identity)
+    ? record
+    : { ...record, coordinatorIdentity: identity, savedAt: now }
+
+/** The record with the lanes' model columns; the same object when unchanged, and a lane without a column keeps its stored one. */
+export const withLaneModels = (record: ResumeRecord, laneModels: Record<string, string>, now: number): ResumeRecord => {
+  const merged = { ...record.laneModels, ...laneModels }
+  return sameStatuses(record.laneModels ?? {}, merged) ? record : { ...record, laneModels: merged, savedAt: now }
+}
+
+/** What the watcher saw at one poll besides the lane statuses; both parts may be unknown. */
+export type Observed = { coordinator?: CoordinatorIdentity | null; laneModels?: Record<string, string> }
+
 /**
  * How often the watcher saves its record although no lane changed: once an hour, so a watcher that rests longer than
  * `RESUME_MAX_AGE_MS` of `decision.ts` without a change still leaves a record young enough to resume after a crash.
@@ -105,8 +143,20 @@ export const refreshedRecord = (record: ResumeRecord, now: number): ResumeRecord
   now - record.savedAt < RESUME_REFRESH_MS ? record : { ...record, savedAt: now }
 
 /** The record after one herdr poll: new statuses, else a new save time once due; the same object when neither. */
-export const followedRecord = (record: ResumeRecord, lanes: Record<string, string>, now: number): ResumeRecord =>
-  refreshedRecord(withLanes(record, lanes, now), now)
+export const followedRecord = (
+  record: ResumeRecord,
+  lanes: Record<string, string>,
+  now: number,
+  observed: Observed = {},
+): ResumeRecord =>
+  refreshedRecord(
+    withLaneModels(
+      withIdentity(withLanes(record, lanes, now), observed.coordinator ?? null, now),
+      observed.laneModels ?? {},
+      now,
+    ),
+    now,
+  )
 
 /** The record stamped as stopped cleanly; null when it names another process, whose record a successor keeps. */
 export const stoppedRecord = (record: ResumeRecord, ownPid: number, now: number): ResumeRecord | null =>

package/src/resume/targets.ts

@@ -2,7 +2,15 @@ import { isRecord } from '../shared/is-record'
 import { parseJsonOrNull } from '../shared/parse-json'
 
 /** One pane an agent runs in, from herdr's lists; `name` is null while herdr names none. */
-export type AgentPane = { pane: string; name: string | null; cwd: string | null }
+export type AgentPane = { pane: string; name: string | null; cwd: string | null; session: string | null }
+
+/** What finds an agent whose name herdr lost: its session id (preferred) and the pane it ran in. */
+export type AgentIdentity = { pane: string | null; session: string | null }
+
+/** How a target was found: by the name, by the session id or pane id of the record, or as the one unnamed pane in the directory. */
+export const TARGET_VIA = { name: 'name', session: 'session', pane: 'pane', directory: 'directory' } as const
+
+export type TargetVia = (typeof TARGET_VIA)[keyof typeof TARGET_VIA]
 
 export const TARGET_MISS = { missing: 'missing', ambiguous: 'ambiguous', elsewhere: 'elsewhere' } as const
 
@@ -12,7 +20,7 @@ export type TargetMiss = (typeof TARGET_MISS)[keyof typeof TARGET_MISS]
 export type TargetMissed = { kind: 'none'; reason: TargetMiss; panes: string[] }
 
 /** Where a message goes: the agent's name or its pane id, `byName` when herdr named it. */
-export type Target = { kind: 'found'; target: string; byName: boolean } | TargetMissed
+export type Target = { kind: 'found'; target: string; byName: boolean; via: TargetVia } | TargetMissed
 
 /** The one unnamed pane found in the directory so far, and in how many polls in a row. */
 export type Streak = { pane: string; polls: number } | null
@@ -34,6 +42,12 @@ const entriesOf = (json: string, key: 'agents' | 'panes'): Record<string, unknow
 
 const stringOrNull = (value: unknown): string | null => (typeof value === 'string' ? value : null)
 
+/** The session id of herdr's `agent_session` (`{ value }`); null for none. */
+export const sessionValueOf = (agentSession: unknown): string | null => {
+  const value = isRecord(agentSession) ? agentSession.value : undefined
+  return typeof value === 'string' && value !== '' ? value : null
+}
+
 /**
  * The agent panes of `herdr agent list` and `herdr pane list`, each once; none from an answer that cannot be read.
  * Right after a restart the pane list names no agent for a few seconds while the agent list already does, and the
@@ -42,33 +56,69 @@ const stringOrNull = (value: unknown): string | null => (typeof value === 'strin
  */
 export const resumablePanesOf = (agentList: string, paneList: string): AgentPane[] => {
   const found = new Map<string, AgentPane>()
-  for (const { pane_id, name, cwd } of entriesOf(agentList, 'agents'))
+  for (const { pane_id, name, cwd, agent_session } of entriesOf(agentList, 'agents'))
     if (typeof pane_id === 'string')
-      found.set(pane_id, { pane: pane_id, name: stringOrNull(name), cwd: stringOrNull(cwd) })
+      found.set(pane_id, {
+        pane: pane_id,
+        name: stringOrNull(name),
+        cwd: stringOrNull(cwd),
+        session: sessionValueOf(agent_session),
+      })
   for (const { pane_id, agent, cwd } of entriesOf(paneList, 'panes')) {
     if (typeof pane_id !== 'string' || (typeof agent !== 'string' && !found.has(pane_id))) continue
     const known = found.get(pane_id)
-    found.set(pane_id, { pane: pane_id, name: known?.name ?? null, cwd: known?.cwd ?? stringOrNull(cwd) })
+    found.set(pane_id, {
+      pane: pane_id,
+      name: known?.name ?? null,
+      cwd: known?.cwd ?? stringOrNull(cwd),
+      session: known?.session ?? null,
+    })
   }
   return [...found.values()]
 }
 
 const missed = (reason: TargetMiss, panes: string[]): TargetMissed => ({ kind: 'none', reason, panes })
 
+const isUnnamedIn = (pane: AgentPane, directory: string): boolean => pane.name === null && pane.cwd === directory
+
+/**
+ * The unnamed pane in `directory` that the record's identity points at: the one with its session id, else (without a
+ * session match) the one with its pane id. A session id names one conversation, so it needs no second look; a pane id
+ * may have passed to another agent, so the caller lets it stay alone for a few polls (`steadyTarget`).
+ */
+const identifiedTarget = (panes: readonly AgentPane[], identity: AgentIdentity, directory: string): Target | null => {
+  const bySession = identity.session === null ? undefined : panes.find((pane) => pane.session === identity.session)
+  if (bySession && isUnnamedIn(bySession, directory))
+    return { kind: 'found', target: bySession.pane, byName: false, via: TARGET_VIA.session }
+  const byPane = identity.pane === null ? undefined : panes.find((pane) => pane.pane === identity.pane)
+  return byPane && !bySession && isUnnamedIn(byPane, directory)
+    ? { kind: 'found', target: byPane.pane, byName: false, via: TARGET_VIA.pane }
+    : null
+}
+
 /**
  * The agent to send to: the one named `name` when it runs in `directory` (the main checkout for the coordinator, the
  * worktree for a lane) or herdr names no directory; the name in another directory belongs to another repository's
  * agent. Without the name, the one unnamed agent pane in `directory`: an agent with another name there is another
- * agent, a helper of the lane for one, and two unnamed panes are never guessed between.
+ * agent, a helper of the lane for one, and two unnamed panes are never guessed between, unless the record's
+ * `identity` (session id, pane id) points at one of them.
  */
-export const targetFor = (panes: readonly AgentPane[], name: string, directory: string): Target => {
+export const targetFor = (
+  panes: readonly AgentPane[],
+  name: string,
+  directory: string,
+  identity?: AgentIdentity,
+): Target => {
   const named = panes.find((pane) => pane.name === name)
   if (named)
     return named.cwd === null || named.cwd === directory
-      ? { kind: 'found', target: name, byName: true }
+      ? { kind: 'found', target: name, byName: true, via: TARGET_VIA.name }
       : missed(TARGET_MISS.elsewhere, [named.pane])
+  const identified = identity ? identifiedTarget(panes, identity, directory) : null
+  if (identified) return identified
   const candidates = panes.filter((pane) => pane.name === null && pane.cwd === directory).map(({ pane }) => pane)
-  if (candidates.length === 1) return { kind: 'found', target: candidates[0] as string, byName: false }
+  if (candidates.length === 1)
+    return { kind: 'found', target: candidates[0] as string, byName: false, via: TARGET_VIA.directory }
   return missed(candidates.length === 0 ? TARGET_MISS.missing : TARGET_MISS.ambiguous, candidates)
 }
 
@@ -77,7 +127,7 @@ export const targetFor = (panes: readonly AgentPane[], name: string, directory:
  * alone for `STEADY_POLLS` polls in a row; until then it counts as missing. Returns the streak for the next poll.
  */
 export const steadyTarget = (target: Target, streak: Streak): { target: Target; streak: Streak } => {
-  if (target.kind === 'none' || target.byName) return { target, streak: null }
+  if (target.kind === 'none' || target.byName || target.via === TARGET_VIA.session) return { target, streak: null }
   const polls = streak?.pane === target.target ? streak.polls + 1 : 1
   const next = { pane: target.target, polls }
   return { target: polls >= STEADY_POLLS ? target : missed(TARGET_MISS.missing, []), streak: next }

package/src/resume/texts.ts

@@ -3,7 +3,12 @@ import { PLAN_LANGUAGE, type PlanLanguage } from '../vocabulary'
 /** The fixed words `jh resume` sends; nothing else from outside reaches a session but checked lane names and the board. */
 export type ResumeTexts = {
   /** One line, no break: herdr would send a break as an enter and split the command. */
-  coordinatorLine: (board: string, interrupted: readonly string[], blocked: readonly string[]) => string
+  coordinatorLine: (
+    board: string,
+    interrupted: readonly string[],
+    blocked: readonly string[],
+    modelCheck?: readonly string[],
+  ) => string
   /** One line, no break: the hand-over script refuses one. The first input of the chat after a clear. */
   clearLine: (board: string) => string
   laneText: string
@@ -11,18 +16,29 @@ export type ResumeTexts = {
 
 const listed = (lanes: readonly string[], none: string): string => (lanes.length > 0 ? lanes.join(', ') : none)
 
+const withModelCheck = (line: string, note: string, lanes: readonly string[]): string =>
+  lanes.length > 0 ? `${line} ${note}: ${lanes.join(', ')}.` : line
+
 const TEXTS: Record<PlanLanguage, ResumeTexts> = {
   [PLAN_LANGUAGE.de]: {
-    coordinatorLine: (board, interrupted, blocked) =>
-      `/orchestrate ${board} Neustart nach Absturz: Watcher starten (§ 4), Wecker mit den Terminen abgleichen; fortgesetzt: ${listed(interrupted, 'keine')}; vor dem Absturz blockiert: ${listed(blocked, 'keine')}.`,
+    coordinatorLine: (board, interrupted, blocked, modelCheck = []) =>
+      withModelCheck(
+        `/orchestrate ${board} Neustart nach Absturz: Watcher starten (§ 4), Wecker mit den Terminen abgleichen; fortgesetzt: ${listed(interrupted, 'keine')}; vor dem Absturz blockiert: ${listed(blocked, 'keine')}.`,
+        'Diese Spuren kamen ohne --model zurück, Modell gegen die Board-Zeile prüfen und nach lane-session.md umstellen',
+        modelCheck,
+      ),
     clearLine: (board) =>
       `/orchestrate ${board} Aufgeräumt: zuerst jh resume --coordinator --board ${board}, dann Watcher starten (§ 4).`,
     laneText:
       'Der Rechner ist abgestürzt und herdr wurde neu gestartet. Dein letzter Befehl wurde unterbrochen: prüfe, wie weit er kam, und setze ihn fort.',
   },
   [PLAN_LANGUAGE.en]: {
-    coordinatorLine: (board, interrupted, blocked) =>
-      `/orchestrate ${board} Restart after a crash: start the watcher (§ 4), match the timers against the appointments; resumed: ${listed(interrupted, 'none')}; blocked before the crash: ${listed(blocked, 'none')}.`,
+    coordinatorLine: (board, interrupted, blocked, modelCheck = []) =>
+      withModelCheck(
+        `/orchestrate ${board} Restart after a crash: start the watcher (§ 4), match the timers against the appointments; resumed: ${listed(interrupted, 'none')}; blocked before the crash: ${listed(blocked, 'none')}.`,
+        'These lanes came back without --model, check the model against the board row and switch it as lane-session.md says',
+        modelCheck,
+      ),
     clearLine: (board) =>
       `/orchestrate ${board} Cleared: first jh resume --coordinator --board ${board}, then start the watcher (§ 4).`,
     laneText:

package/src/watch/command.ts

@@ -52,8 +52,9 @@ import { CLOCK_LOCALE, type PlansSettings, plansSettingsOf, worktreeOf } from '.
 import { readRunningSubagents, subagentSourceOf } from '../plans/subagents-read'
 import { boardTexts } from '../plans/texts'
 import { readWaitingRecords, waitingItemsOf } from '../plans/waiting-records'
-import { keepRecord } from '../resume/keeper'
+import { coordinatorIdentityOf, keepRecord, laneModelColumnsOf } from '../resume/keeper'
 import { systemRecordStore } from '../resume/ports'
+import type { Observed } from '../resume/record'
 import { defaultUpdateCheck } from '../sync/if-changed'
 import { DEFAULT_SKILL_PREFIX } from '../sync/init'
 import { herdrLaneStatusSource } from '../terminal/herdr'
@@ -1597,7 +1598,15 @@ const watchLanes = async (watch: Watch): Promise<boolean> => {
     Date.now(),
     { store: systemRecordStore(watch.root), log: console.log },
   )
-  resumeRecord.follow(armed, Date.now())
+  const observed = (): Observed => ({
+    coordinator: coordinatorIdentityOf(
+      watching.agents,
+      coordinatorNameFor(watch, watching.agents),
+      process.env.HERDR_PANE_ID,
+    ),
+    laneModels: laneModelColumnsOf(watching.laneModelReadings),
+  })
+  resumeRecord.follow(armed, Date.now(), observed())
   process.on('SIGTERM', () => {
     resumeRecord.stop(Date.now())
     saveState(watch, watching)
@@ -1629,7 +1638,7 @@ const watchLanes = async (watch: Watch): Promise<boolean> => {
     while (await pollOnce(watch, watching)) {
       await Bun.sleep(POLL_MS)
       pollLanes(watch, watching)
-      resumeRecord.follow(watching.current, Date.now())
+      resumeRecord.follow(watching.current, Date.now(), observed())
       await announceUpdate?.()
       if (endedByKitUpdate(kit, effects)) return true
     }

package/src/watch/lane-watch.ts

@@ -1,6 +1,12 @@
 import { AGENT_STATUS } from '../terminal/types'
 
-export type HerdrAgent = { name?: string; pane_id: string; agent_status: string; state_change_seq?: number }
+export type HerdrAgent = {
+  name?: string
+  pane_id: string
+  agent_status: string
+  agent_session?: unknown
+  state_change_seq?: number
+}
 
 /** The state a report gives a lane whose agent left the herdr listing. */
 export const LANE_GONE = 'no longer listed'