jackherd 1.12.4 → 1.12.6

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 What changed for people who use jackherd, newest first.
 
+## 1.12.6
+
+- **The coordinator has a line in the herd.** While every lane rests and the coordinator works (a diagnosis, a review, a release), the herd no longer looks like a standstill: a line over the lanes, under "Your turn" and "Sources", set like the head of a block of one line, reads `● Jack · working · <task> · since 12:54`: the coordinator's state, the task it reported with `jh task start` from the main checkout and since when, its context fill at the right edge; at rest `○ Jack · idle`, without the last task. The name stands in the column of the block names. While the coordinator works, its task shimmers like the running task of a folded lane (and stands still in teal with `plans.shimmer: false`). A long task is cut with `…`, the time and the fill stay. The line is no lane and stays when "Lanes" is folded. That task no longer shows as a separate `now:` line. A lane's own herd shows no coordinator line. The orchestrate skill tells the coordinator to report each step of its own that way, and `jh task done` at its end.
+
+## 1.12.5
+
+- **A lane that stands still is news.** Since 1.12.4 an unchanged heartbeat stays silent, so a working lane whose phase, ticks and subagents do not move would go unnoticed. `jh watch --stream` now reports such a lane once, after three heartbeat intervals without a move (45 minutes at the default 15), as its own line `lane <name> stalled <n> min`, and stays silent until the lane moves again. The orchestrate skill tells the coordinator to read that lane, instead of comparing counts across heartbeats.
+
 ## 1.12.4
 
 - **A quiet stream when nothing changed.** `jh watch --stream` sends a heartbeat only when its state (lanes, their progress, what waits on you, the main checkout) changed since the last one it sent, so a coordinator's chat no longer fills with identical heartbeats over hours. The events a heartbeat brings (parallel tasks, a lane without a task signal, an unlinked Artifact) come as before.

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.12.4/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.12.6/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)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.12.4/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)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.12.6/assets/icons/space.svg">
 
 # Jack herds your coding agents.
 
@@ -15,25 +15,25 @@ 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.12.4/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.12.6/assets/icons/space.svg">
 
 <p>
-<img src="https://unpkg.com/jackherd@1.12.4/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.12.6/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.12.4/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.12.6/assets/icons/space.svg">
 </p>
 
-<p><img src="https://unpkg.com/jackherd@1.12.4/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.12.6/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.12.4/assets/icons/bark.svg" width="24" height="34" align="middle" alt=""> <b>Jack barks.</b><br>A blocked lane, a red check, a review comment: Jack wakes, and the herd view shows where every lane stands.</p>
+<p><img src="https://unpkg.com/jackherd@1.12.6/assets/icons/bark.svg" width="24" height="34" align="middle" alt=""> <b>Jack barks.</b><br>A blocked lane, a red check, a review comment: Jack wakes, and the herd view shows where every lane stands.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.12.4/assets/icons/ear.svg" width="24" height="34" align="middle" alt=""> <b>Jack listens.</b><br>Review comments go to the lane that fixes them, with a test. <code>/jh-follow</code> brings anything with a CLI or an API into the herd: tickets, error logs, status pages, deploys, and whatever else you point it at.</p>
+<p><img src="https://unpkg.com/jackherd@1.12.6/assets/icons/ear.svg" width="24" height="34" align="middle" alt=""> <b>Jack listens.</b><br>Review comments go to the lane that fixes them, with a test. <code>/jh-follow</code> brings anything with a CLI or an API into the herd: tickets, error logs, status pages, deploys, and whatever else you point it at.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.12.4/assets/icons/bowl.svg" width="24" height="34" align="middle" alt=""> <b>Picks up where you left off.</b><br>Plan and board hold the state, not the chat.</p>
+<p><img src="https://unpkg.com/jackherd@1.12.6/assets/icons/bowl.svg" width="24" height="34" align="middle" alt=""> <b>Picks up where you left off.</b><br>Plan and board hold the state, not the chat.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.12.4/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.</p>
+<p><img src="https://unpkg.com/jackherd@1.12.6/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.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.12.4/assets/icons/decide.svg" width="24" height="34" align="middle" alt=""> <b>You make the calls.</b><br>Nothing is committed, pushed or merged without your approval. Jack merges on green checks only where you said so: one pull request, or a plan's for up to 24 hours.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.12.4/assets/icons/space.svg"></p>
+<p><img src="https://unpkg.com/jackherd@1.12.6/assets/icons/decide.svg" width="24" height="34" align="middle" alt=""> <b>You make the calls.</b><br>Nothing is committed, pushed or merged without your approval. Jack merges on green checks only where you said so: one pull request, or a plan's for up to 24 hours.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.12.6/assets/icons/space.svg"></p>
 
 ## Quickstart
 
@@ -69,22 +69,22 @@ Then `/jh-start` in a repository, and Jack offers your first plan. → [Quicksta
    /jh-orchestrate docs/plans/board-<name>/board.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. → [INSTALL.md](https://unpkg.com/jackherd/INSTALL.md)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.12.4/assets/icons/space.svg">
+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. → [INSTALL.md](https://unpkg.com/jackherd/INSTALL.md)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.12.6/assets/icons/space.svg">
 
 ## Follow anything outside GitHub
 
 Whatever you check by hand, Jack can watch: tickets, error logs, status pages, deploys. One `/jh-follow`, one yes, and every change comes to you like this:
 
-<img src="https://unpkg.com/jackherd@1.12.4/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.12.6/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: per source its new entries, or when it last ran, red while it fails; opened, a click on an entry opens it. A ticket shows on the lane that works it, and a row in Your turn that came from a source starts with that source's label.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.12.4/assets/icons/space.svg">
+The herd sums up your sources in one `Sources` line: per source its new entries, or when it last ran, red while it fails; opened, a click on an entry opens it. A ticket shows on the lane that works it, and a row in Your turn that came from a source starts with that source's label.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.12.6/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.12.4/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.12.6/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 |
 | --- | --- | --- |
@@ -117,7 +117,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.12.4/docs/skills-dark.svg" alt="/jh-grill hands decisions to /jh-plan; /jh-plan feeds /jh-orchestrate or a single /jh-implement; /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.12.6/docs/skills-dark.svg" alt="/jh-grill hands decisions to /jh-plan; /jh-plan feeds /jh-orchestrate or a single /jh-implement; /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.12.4"
+version = "1.12.6"
 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.12.4}"
+JACKHERD_VERSION="${JACKHERD_VERSION:-1.12.6}"
 
 JACKHERD_PACKAGE='jackherd'
 # Test seam: the terminal the wizard asks its questions on.

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

@@ -99,7 +99,7 @@ When the user wants a plan's lanes merged without a question for a while: § 5,
 2. **Worktree workspace** from `<base>`: `origin/{{kit.baseBranch}}` when, after
    `git fetch origin {{kit.baseBranch}}`, `git cat-file -e origin/{{kit.baseBranch}}:<plan>` succeeds
    for the lane's plan, else `origin/docs/plan-<topic>` of step 0. The file decides, not the state of
-   the PR, so a lane started after a hand-over or after the merge gets the right base:
+   the PR, so a later lane gets the right base:
    ```bash
    herdr worktree create --cwd <main-checkout> --branch <branch> --base <base> \
      --path <main-checkout>/{{kit.worktreeDirectory}}/<lane> --label "<lane> :<port>" --no-focus
@@ -115,8 +115,8 @@ When the user wants a plan's lanes merged without a question for a while: § 5,
      `## {{kit.heading.lanes}}` table has the lane's row: lane, port, plan, phases, starts after,
      model. The phases cell starts with the phase id (`P10c …`), also for a sub-phase, and the plan
      column links the plan once it exists, in the PR that adds the plan, in the row of every lane that
-     implements one of its phases. `/plan` may have written the row
-     already. Check that this prints it, and write it first if it prints nothing:
+     implements one of its phases. Check that this prints it, else
+     write it first:
      ```bash
      grep -F "| \`<lane>\`" <board>
      ```
@@ -147,8 +147,8 @@ at it before the PR question (§ 5). The command is the project's dev server on
 (`PORT=<port> {{kit.command.dev}}`, unless the project supplement names another).
 
 Never in the lane's shell: the agent would block on it. Split a pane inside the lane's workspace
-and run it there, **beside the agent** (`--direction right`), so the agent's dialogs and diffs keep
-their height:
+and run it there, **beside the agent** (`--direction right`), so the agent keeps
+its height:
 
 ```bash
 herdr pane split <lane-pane> --direction right --no-focus
@@ -192,16 +192,14 @@ watcher finds you by the default name of § 0, or by `--coordinator <name>`. In
 arrives as one message, and the watcher keeps running.
 
 The heartbeat (default 15 minutes, due after that long without a report) is one line,
-`=== heartbeat <time> · <lane> <status> · …`, sent only on a change. Each working lane carries its current phase and its ticks
-(`<lane> working: P12 7/12`) and the subagents running in its worktree
-(`P12 7/12, 3 subagents`). A lane whose count stays put with no subagent running is
-one to read yourself. `lane added: <name>` and `lane removed: <name>` mark a change of the found lanes.
+`=== heartbeat <time> · <lane> <status> · …`, sent only on a change. Each working lane carries its current phase, its ticks
+and the subagents in its worktree (`<lane> working: P12 7/12, 3 subagents`). A working lane whose line stands
+still three heartbeat intervals comes once as `lane <name> stalled <n> min`. `lane added: <name>` and `lane removed: <name>` mark a change.
 An agent is watched from the state it first shows; one that exits fires as `no longer listed`.
 Deploy runs are reported only when the config sets `watch.deploy`.
 
 Something outside GitHub (a ticket, an issue, an error, a status page) the watcher reports only as
-a configured source (`watch.sources`). When the user asks you to follow such an item ("follow X",
-"tell me when X answers"), run `/follow`.
+a configured source (`watch.sources`). When the user asks you to follow such an item, run `/follow`.
 
 A restart is safe: the watcher keeps what it saw between runs. A stop during a report re-delivers that
 report's events on the next arm; vet a repeated event against `gh pr view` or the run before acting
@@ -215,17 +213,18 @@ twice.
   (`TaskStop`) and start it under the Monitor tool.
 - **Only when the session has no Monitor tool**, even after `ToolSearch`, the watcher runs without
   `--stream` as its own Bash call with `run_in_background: true`. It returns after one report and is
-  started again after every wake-up. Tell the user in one sentence that this session watches without a stream
-  because it has no Monitor tool, unless the provider has none (above). A watcher sent off with a trailing `&` finishes unseen.
+  started again after every wake-up. Tell the user in one sentence that this session watches without a stream,
+  unless the provider has none (above). A watcher sent off with a trailing `&` finishes unseen.
 - **A wake-up is done when every watched lane has a started next action or a named reason to wait**
   (`waiting for merge #<n>`, `waiting for mockup approval`, `plan finished, close the lane?`).
 - **Start the stream again only when it ended:** the monitor expired (its notice after 30 minutes),
   `stopped by SIGTERM` from outside, or `watcher stopped: <reason>`. Start it before answering the
   user. A watcher with named lanes is restarted with every lane still running.
 
-**Herd for the user.** The watcher wakes you; the herd shows the user where every lane stands. The
-watcher keeps the herd panes beside your pane and beside each lane of the board and prints a line per
-view it started. On `herd --ensure failed, still watching: <reason>`, fix the cause and run
+**Herd for the user.** The herd shows the user where every lane and you stand: report each step of
+your own with `jh task start "<task>"` from the main checkout and
+`jh task done` at its end. The watcher keeps
+the herd panes beside yours and each lane's and prints a line per view it started. On `herd --ensure failed, still watching: <reason>`, fix the cause and run
 `bunx jackherd herd --ensure` from your pane. How the herd picks a lane's phases is in
 [`references/herd.md`](references/herd.md). `herd --once` prints a single frame for you to read; never
 run the live view in your own shell.
@@ -248,10 +247,11 @@ On wake-up:
 | `checks passed #<n>` | One line to the user: ready to merge, with the board's merge order |
 | `deploy …` | Result and target as the run states them, to the user; a target `unknown (…)` is reported as unknown, never guessed. A failed run goes to the user as an `AskUserQuestion`: read the logs now or later |
 | `due <when> · <action>` | An open appointment fell due (**An agreed time**, below); the action is cut to 160 characters, the board row holds it whole. Carry it out as agreed, under the approvals it needs (§ 5), then write the outcome into its status cell in the same turn |
-| `heartbeat` | One line of status to the user; a resting lane carries `waits on: <question>, <n> open questions` from its report, and `for you (<n>): …` names what still waits on the user (**Anything that waits on the user's answer**, below): the `for you` part of that line is the count only (`3 wait for you, see the herd`, in the language of the replies); the herd shows the items, and no reply of yours ends with a list of the rows of the board section |
+| `heartbeat` | One line of status to the user; a resting lane carries `waits on: <question>, <n> open questions` from its report, and `for you (<n>): …` names what still waits on the user (**Anything that waits on the user's answer**, below): the `for you` part of that line is the count only (`3 wait for you, see the herd`, in the language of the replies); no reply of yours ends with a list of the rows of the board section |
 | `gh unavailable` | Tell the user once; herdr watching continues |
 | `lane <name> warn` | One line to the user: the lane's fill and that it hands over at a phase boundary if it rises further; no step in the lane |
 | `lane <name> alert` | § 8: send the lane once the request for its hand-over at the end of its current phase |
+| `lane <name> stalled <n> min` | Read its screen: running subagents or moving output are a reason to wait; a stopped lane gets its next step |
 | `approval <name> <id> <tool> · <call>` | A call of the lane waits for the user's approval (**Approvals**, below); the duty line names the question's mark and labels |
 | `coordinator warn` / `coordinator alert` | § 8, for yourself |
 | `lane added: <name>` | Nothing: the lane is watched. Check that it has its row (§ 2 step 5); a name `<lane>-<purpose>` without a worktree is a helper agent of that lane and needs no row. One the lane did not announce goes to the user |

package/package.json

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

package/src/plan-format/clock.ts

@@ -5,8 +5,14 @@ export const DAY_MS = 86_400_000
 /** A day, month, hour or minute with a leading zero: `7` → `07`. */
 export const twoDigits = (value: number): string => String(value).padStart(2, '0')
 
+/** The time of day: `HH:MM`. */
+export const timeOfDayText = (at: number): string => {
+  const date = new Date(at)
+  return `${twoDigits(date.getHours())}:${twoDigits(date.getMinutes())}`
+}
+
 /** A time as the for-you rows show it: `DD.MM. HH:MM`. */
 export const clockText = (at: number): string => {
   const date = new Date(at)
-  return `${twoDigits(date.getDate())}.${twoDigits(date.getMonth() + 1)}. ${twoDigits(date.getHours())}:${twoDigits(date.getMinutes())}`
+  return `${twoDigits(date.getDate())}.${twoDigits(date.getMonth() + 1)}. ${timeOfDayText(at)}`
 }

package/src/plans/coordinator-row.ts

@@ -0,0 +1,95 @@
+import type { ContextReading } from '../context'
+import { COORDINATOR_NAME_PREFIX, resolveCoordinatorName } from '../context/coordinator-name'
+import { clockText, timeOfDayText } from '../plan-format/clock'
+import { terminalSafe } from '../plan-format/terminal-text'
+import type { TaskSignal } from '../task-signals/types'
+import { fit, visibleLength } from '../terminal/text'
+import { AGENT_STATUS, type LaneAgent } from '../terminal/types'
+import { laneOfDirectory } from './active-tasks'
+import { statusWord } from './symbols'
+
+export type CoordinatorTask = Pick<TaskSignal, 'text' | 'startedAt'>
+
+/** What the herd's coordinator line shows: the agent's name and state, its task, and its fill when the log gives one. */
+export type CoordinatorView = {
+  name: string
+  status: string | null
+  task: CoordinatorTask | null
+  context: ContextReading | null
+  /** When the herd read it: a task of the same day shows its time of day, an older one its date. */
+  readAt: number
+}
+
+/** How the coordinator's text is set: the cells it may take, the paint of its state, the style of its task. */
+export type CoordinatorTextOptions = {
+  width?: number
+  paintState?: (state: string) => string
+  taskStyle?: (task: string) => string
+}
+
+/**
+ * The coordinator among the terminal's agents: `jack-<repository>` (the default name of `/orchestrate` § 0), else the
+ * old `orchestrator-<repository>`; null when none runs. A name given to the watcher with `--coordinator` is not known here.
+ */
+export const coordinatorAgentOf = (agents: readonly LaneAgent[], repository: string): LaneAgent | null => {
+  const name = resolveCoordinatorName(
+    repository,
+    agents.map((agent) => agent.name),
+  )
+  return agents.find((agent) => agent.name === name) ?? null
+}
+
+/**
+ * The coordinator's task: the newest signal reported outside the lanes' worktrees, where the coordinator works (its
+ * Claude task list, or `jh task start` from the main checkout); null without one.
+ */
+export const coordinatorTaskOf = (signals: readonly TaskSignal[], worktrees: string): TaskSignal | null =>
+  signals
+    .filter(({ cwd }) => laneOfDirectory(cwd, worktrees) === null)
+    .reduce<TaskSignal | null>(
+      (newest, signal) => (newest && newest.startedAt >= signal.startedAt ? newest : signal),
+      null,
+    )
+
+const isSameDay = (first: number, second: number): boolean =>
+  new Date(first).toDateString() === new Date(second).toDateString()
+
+/** `HH:MM` for a time of today, `DD.MM. HH:MM` for an earlier day. */
+const sinceText = (startedAt: number, now: number): string =>
+  isSameDay(startedAt, now) ? timeOfDayText(startedAt) : clockText(startedAt)
+
+const roleName = (prefix: string): string => `${prefix.charAt(0).toUpperCase()}${prefix.slice(1)}`
+
+/**
+ * The role name `Jack` for `jack-shop`, `Orchestrator` for the old `orchestrator-shop`: the herd's title names the
+ * repository. Another name stays as it is, made terminal safe.
+ */
+export const coordinatorShortName = (name: string): string => {
+  const prefix = Object.values(COORDINATOR_NAME_PREFIX).find((each) => name === each || name.startsWith(`${each}-`))
+  return prefix ? roleName(prefix) : terminalSafe(name)
+}
+
+const TEXT_SEPARATOR = ' · '
+/** The fewest cells a cut task keeps: one character and its ellipsis. */
+const MIN_TASK_WIDTH = 2
+
+const unstyled = (text: string): string => text
+
+/**
+ * `working · <task> · since 12:30` in at most `width` cells, the state in `paintState`, the task alone in
+ * `taskStyle` (the herd's shimmer): the task is cut with `…`, state and since when never; the task is left out where
+ * not even its ellipsis fits. Only a working coordinator shows its task: at rest, or without a task, the state
+ * stands alone (`idle`), so an old task does not read as running.
+ */
+export const coordinatorText = (
+  { status, task }: Pick<CoordinatorView, 'status' | 'task'>,
+  now: number,
+  { width = Number.POSITIVE_INFINITY, paintState = unstyled, taskStyle = unstyled }: CoordinatorTextOptions = {},
+): string => {
+  const state = terminalSafe(statusWord(status))
+  if (!task || status !== AGENT_STATUS.working) return paintState(state)
+  const since = `since ${sinceText(task.startedAt, now)}`
+  const room = width - visibleLength(state) - visibleLength(since) - 2 * TEXT_SEPARATOR.length
+  const middle = room < MIN_TASK_WIDTH ? [] : [taskStyle(fit(terminalSafe(task.text), room))]
+  return [paintState(state), ...middle, since].join(TEXT_SEPARATOR)
+}

package/src/plans/herd-state.ts

@@ -82,15 +82,19 @@ export const storedRead = (read: PublishedRead, key: string, at: number): HerdRe
 }
 
 /**
- * The snapshot with its clocks set to `now`: the sources' ages and your turn's, which the reader draws at its own
- * time with every read.
+ * The snapshot with its clocks set to `now`: the sources' ages, your turn's and the coordinator's, which the reader
+ * draws at its own time with every read.
  */
-const clockedAt = <T extends Pick<Snapshot, 'sourceBlock' | 'yourTurn'>>(snapshot: T, now: number): T => {
-  const { sourceBlock, yourTurn, ...rest } = snapshot
+const clockedAt = <T extends Pick<Snapshot, 'sourceBlock' | 'yourTurn' | 'coordinator'>>(
+  snapshot: T,
+  now: number,
+): T => {
+  const { sourceBlock, yourTurn, coordinator, ...rest } = snapshot
   return {
     ...rest,
     ...(sourceBlock ? { sourceBlock: { ...sourceBlock, now } } : {}),
     ...(yourTurn ? { yourTurn: { ...yourTurn, now } } : {}),
+    ...(coordinator ? { coordinator: { ...coordinator, readAt: now } } : {}),
   } as T
 }
 
@@ -147,6 +151,7 @@ export const laneRead = (snapshot: Snapshot, lane: string, laneNotListed: (lane:
     titles: new Map([...snapshot.titles].filter(([titled]) => titled === pane)),
     panes: pane ? { [lane]: pane } : {},
     unplaced: [],
+    coordinator: undefined,
   }
 }
 

package/src/plans/layout.ts

@@ -33,6 +33,7 @@ import {
 } from '../watch/plan-badges'
 import type { UnplannedTask } from './active-tasks'
 import { type AgentOf, clickHint } from './click-hint'
+import { type CoordinatorView, coordinatorShortName, coordinatorText } from './coordinator-row'
 import { type Frame, indented, joinFrames, narrower, rowFrame, spaced, textFrame, unpainted } from './frame'
 import { groomedText } from './groomed'
 import {
@@ -161,6 +162,8 @@ export type OverviewView = {
   groomedDays?: number | null
   /** What agents report doing that no lane takes, one `now:` line each under the title. */
   unplaced?: UnplannedTask[]
+  /** The coordinator's state, task and fill, one line over the lanes, under the blocks on top. */
+  coordinator?: CoordinatorView
   /** True when a folded lane's running task shimmers (`shimmerAt` draws it) instead of carrying its `●`. */
   shimmer?: boolean
 }
@@ -457,6 +460,26 @@ const CONTEXT_PAINT: Record<ContextLevel, (text: string) => string> = {
 const contextValue = (context: ContextReading | null | undefined): string =>
   context ? `${CONTEXT_SYMBOL}${CONTEXT_PAINT[context.level](contextLabel(context.share).padStart(CONTEXT_WIDTH))}` : ''
 
+/** The coordinator's state word: working in the tone of working lanes, at rest dim as in the head of the lanes. */
+const coordinatorStatePaint = (status: string | null): ((text: string) => string) =>
+  status === AGENT_STATUS.working || status === AGENT_STATUS.blocked ? statusPaint(status) : paint.dim
+
+/**
+ * The coordinator's line over the lanes, set like the head of a block of one line: its state's symbol where a head
+ * has its chevron, one cell wide, so the name starts in the column of the heads' names; then
+ * `Jack · working · <task> · since 12:30`, its fill at the right edge where the lanes have it. The task alone is cut
+ * to fit, and drawn in `taskStyle` like the running task of a folded lane: it shimmers while the herd does.
+ */
+const coordinatorLine = (view: CoordinatorView, width: number, taskStyle: TaskStyle): string => {
+  const paintState = coordinatorStatePaint(view.status)
+  const name = paint.bold(coordinatorShortName(view.name))
+  const head = `${paintState(statusSymbol(view.status))} ${name}${PLACE_SEPARATOR}`
+  const context = contextValue(view.context)
+  const room = width - visibleLength(head) - (context ? visibleLength(context) + 1 : 0)
+  const text = coordinatorText(view, view.readAt, { width: room, paintState, taskStyle })
+  return spread(`${head}${text}`, context, width)
+}
+
 /**
  * The context value with a rule before the bar that follows it on a folded lane line, from `warn` on; below, blanks
  * as wide, so nothing moves when it shows. Empty without a reading.
@@ -1344,6 +1367,7 @@ export const renderScreen = (
     sourceBlock,
     groomedDays,
     unplaced = [],
+    coordinator,
     shimmer,
   }: OverviewView,
   state: Selection,
@@ -1367,7 +1391,11 @@ export const renderScreen = (
     textFrame(parkedBlock(noAgent, width)),
     ...(planned.length > 0 ? [backlogFrame(planned, state, width)] : []),
   ]
-  const plainHeader = [...above, ...(stack.lines.length > 0 ? stack.lines : [''])]
+  const plainHeader = [
+    ...above,
+    ...(stack.lines.length > 0 ? stack.lines : ['']),
+    ...(coordinator ? [coordinatorLine(coordinator, width, taskStyle), ''] : []),
+  ]
   const plainBody = spaced(sections)
   const blockHits = stack.hits.flatMap(focusHitsOfBlock)
   const focusHits = [...blockHits, ...focusHitsOfTargets(plainBody.targets, plainHeader.length)]

package/src/plans/snapshot.ts

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs'
-import { dirname, join } from 'node:path'
+import { basename, dirname, join } from 'node:path'
 import type { ContextReading } from '../context'
+import { coordinatorSettings } from '../context/options'
 import { type AgentLogReader, contextOfAgent } from '../context/report'
 import { agentLog, defaultProjectsDirectory } from '../context/session-log'
 import {
@@ -25,6 +26,7 @@ import { readWatchReading } from '../watch/plan-badges-read'
 import type { SourceStatus } from '../watch/source-statuses'
 import { assignSignals, laneOfDirectory, type UnplannedTask } from './active-tasks'
 import { type BoardRowsReader, boardRowsOf } from './board-rows'
+import { type CoordinatorView, coordinatorAgentOf, coordinatorTaskOf } from './coordinator-row'
 import {
   type ActivityTimes,
   type LaneMemory,
@@ -140,6 +142,8 @@ export type Snapshot = {
   tones?: PlansSettings['tones']
   /** What agents report doing that no lane takes: the coordinator's own, or a lane the board does not list. */
   unplaced?: UnplannedTask[]
+  /** The coordinator's state, task and fill, for its line over the lanes; absent while none runs or one lane is shown. */
+  coordinator?: CoordinatorView
 }
 
 type LaneSources = {
@@ -414,6 +418,25 @@ const readSignals = async (
   }
 }
 
+/**
+ * The coordinator's line for the overview, with the signal it shows as its task: its agent's state, that task and its
+ * fill against the coordinator's thresholds; null while no coordinator runs.
+ */
+const coordinatorOf = (sources: LaneSources): { view: CoordinatorView; shown: TaskSignal | null } | null => {
+  const agent = coordinatorAgentOf(sources.agents, basename(sources.source.root))
+  if (!agent) return null
+  const shown = coordinatorTaskOf(sources.signals, sources.worktrees)
+  const report = contextOfAgent(agent, sources.readLog, coordinatorSettings(sources.source.settings.context))
+  const view = {
+    name: agent.name,
+    status: agent.status,
+    task: shown && { text: shown.text, startedAt: shown.startedAt },
+    context: report && { share: report.share, level: report.level },
+    readAt: sources.now,
+  }
+  return { view, shown }
+}
+
 /** The reports no shown lane takes, as lines for the overview: the coordinator's own and those of lanes without a plan. */
 const unplacedOf = (sources: LaneSources, lanes: readonly SprintLane[], onlyLane: boolean): UnplannedTask[] => {
   if (onlyLane) return []
@@ -721,6 +744,11 @@ export const loadSnapshot = async (
     baseCommit,
   })
   if (parsed) dropUnused(parsed.entries, parsed.used)
+  const coordinator = options.lane ? null : coordinatorOf(laneSet.sources)
+  const unplacedSources = {
+    ...laneSet.sources,
+    signals: laneSet.sources.signals.filter((signal) => signal !== coordinator?.shown),
+  }
   await gate.pass()
   return {
     title: unknownLaneTitle ?? sprintTitleOf(markdown, sprintDirectory),
@@ -746,7 +774,8 @@ export const loadSnapshot = async (
     yourTurn: yourTurnOfBoard(liveBoard, settings.planLanguage, waiting, now),
     ...(reading?.sources ? { sourceBlock: { sources: withSourceStyle(reading.sources, settings), now } } : {}),
     tones: settings.tones,
-    unplaced: unplacedOf(laneSet.sources, laneSet.lanes, Boolean(options.lane)),
+    ...(coordinator ? { coordinator: coordinator.view } : {}),
+    unplaced: unplacedOf(unplacedSources, laneSet.lanes, Boolean(options.lane)),
     ...(ticketSources.length > 0 ? { watchesTickets: true } : {}),
   }
 }

package/src/plans/view.ts

@@ -49,6 +49,7 @@ const overviewOf = (snapshot: Snapshot, shimmer: boolean): OverviewView => {
     yourTurn: snapshot.yourTurn,
     sourceBlock: snapshot.sourceBlock,
     unplaced: snapshot.unplaced,
+    coordinator: snapshot.coordinator,
     shimmer,
   }
 }

package/src/watch/command.ts

@@ -87,7 +87,7 @@ import {
 import { type FeedbackItem } from './feedback-item'
 import { type FeedbackItemsRead, readCommentItems, readFeedbackItems, readOwnLogin } from './feedback-read'
 import { answered, deployTargetOf, type GithubRead, readGithub, targetText } from './github-read'
-import { currentPhaseCountsOf } from './heartbeat-progress'
+import { currentPhaseCountsOf, type LaneNotes } from './heartbeat-progress'
 import { startHerdPublisher } from './herd-publisher'
 import { agentScreen, listAgents } from './herdr'
 import { endedByKitUpdate } from './kit-update'
@@ -120,6 +120,7 @@ import {
 import { hasLaneHandover, laneReportPath, readLaneReport, reportMtime } from './lane-report-file'
 import { restNote } from './lane-rest'
 import { branchOf, fetchBaseWhenMoved, fetchPlanHeadsWhenMoved, readMainCheckout } from './lane-sources'
+import { type LaneStalledEvent, laneStalledEvents, STALLED_HEARTBEATS, type StallState } from './lane-stalled'
 import {
   advanceBaseline,
   armBaseline,
@@ -306,6 +307,8 @@ type Watching = {
   parallelAutoEnded: string | null
   /** Since when each lane works without a task signal and the phase last reported; persisted like the fingerprints. */
   noTaskSignals: NoSignalState
+  /** The working lanes' positions at the last heartbeat and since when they stand; persisted like the fingerprints. */
+  laneStalls: StallState
   /** The open artifact sends in their grace or already reported as `unlinked artifact`; persisted like the fingerprints. */
   unlinkedArtifacts: UnlinkedState
   /** The approval requests of the last poll; null before the first read, so the stored ids stay. */
@@ -360,6 +363,7 @@ const recordedOf = (watch: Watch, watching: Watching): WatchState => {
     taskParallels: watching.taskParallels,
     parallelAutoEnded: watching.parallelAutoEnded,
     noTaskSignals: watching.noTaskSignals,
+    laneStalls: watching.laneStalls,
     unlinkedArtifacts: watching.unlinkedArtifacts,
     approvals: watching.approvalRequests ? recordApprovals(watching.approvalRequests) : withReads.approvals,
     sources: recordWatchedSources(withReads.sources, watching.sourceRuns, watch.sources, watching.githubReadAt),
@@ -1160,11 +1164,27 @@ const subagentCountsOf = (watch: Watch, now: number): Record<string, number> =>
   }
 }
 
+/**
+ * This heartbeat's `stalled` events: the working lanes whose position (the heartbeat's note) stood still for
+ * `STALLED_HEARTBEATS` heartbeat intervals, each once per stretch; records the state in `watching`.
+ */
+const laneStalledEventsOf = (watch: Watch, watching: Watching, notes: LaneNotes, now: number): LaneStalledEvent[] => {
+  const working = new Set(workingLanes(watching))
+  const readings = Object.fromEntries(
+    watching.lanes.map((lane) => [lane, { working: working.has(lane), position: notes[lane] ?? '' }]),
+  )
+  const limitMinutes = watch.options.heartbeatMinutes * STALLED_HEARTBEATS
+  const { events, state } = laneStalledEvents(watching.laneStalls, readings, now, limitMinutes)
+  watching.laneStalls = state
+  return events
+}
+
 /**
  * The heartbeat of a stream: one line, a working lane with its phase count at every heartbeat and the subagents running
- * in its worktree, printed only when its state changed since the last one sent. The plans are read only when a lane
- * works; a board that cannot be read leaves the lines without a count, and the next report names the failure. Returns
- * the state of the heartbeat it printed, null when it printed none.
+ * in its worktree, printed only when its state changed since the last one sent; a lane whose position stood still for
+ * `STALLED_HEARTBEATS` intervals comes as its own `stalled` event. The plans are read only when a lane works; a board that cannot be
+ * read leaves the lines without a count, and the next report names the failure. Returns the state of the heartbeat it
+ * printed, null when it printed none.
  */
 const printStreamHeartbeat = async (watch: Watch, watching: Watching, now: number): Promise<string | null> => {
   const working = workingLanes(watching)
@@ -1182,6 +1202,7 @@ const printStreamHeartbeat = async (watch: Watch, watching: Watching, now: numbe
   const sent = isHeartbeatNews(watching.state.heartbeat, line) ? heartbeatStateOf(line) : null
   if (sent !== null) console.log(line)
   const events = [
+    ...laneStalledEventsOf(watch, watching, notes, now),
     ...taskParallelEventsOf(watch, watching, now),
     ...noTaskSignalEventsOf(watch, watching, progress, now),
     ...unlinkedArtifactEventsOf(watch, watching),
@@ -1284,6 +1305,7 @@ const initialWatching = (
   taskParallels: start.state.taskParallels,
   parallelAutoEnded: start.state.parallelAutoEnded,
   noTaskSignals: start.state.noTaskSignals,
+  laneStalls: start.state.laneStalls,
   unlinkedArtifacts: start.state.unlinkedArtifacts,
   approvalRequests: null,
   appointments: null,

package/src/watch/lane-report.ts

@@ -11,6 +11,7 @@ import { type FeedbackEvent, firstLine } from './feedback'
 import type { LaneFillEvent } from './lane-fill'
 import type { LaneModelEvent } from './lane-model'
 import type { LaneParallelEvent } from './lane-parallel'
+import { laneStalledLine } from './lane-stalled'
 import { AGENT_STATUS, type LaneSnapshot, NO_AGENT } from './lane-watch'
 import { PULL_REQUEST_STATE, type WatchedPullRequest } from './pull-requests'
 import { SOURCE_FIELD } from './source-fields'
@@ -150,6 +151,19 @@ export const otherPullRequestsLine = (
   return `${texts.otherPullRequests}: ${[...named, ...(more > 0 ? [`+${more}`] : [])].join(' · ')}`
 }
 
+/** The header line of an event about one lane's agent (fill, model, parallel phases, task signal, standing still); null for any other. */
+const laneEventLine = (event: WatchEvent): string | null => {
+  if (event.kind === WATCH_EVENT.laneFill)
+    return `=== ${event.kind} ${terminalSafe(event.lane)} ${event.level} ${contextLabel(event.share)}`
+  if (event.kind === WATCH_EVENT.laneModel)
+    return `=== ${event.kind} ${terminalSafe(event.lane)} ${terminalSafe(event.model)} · board ${terminalSafe(event.column)}`
+  if (event.kind === WATCH_EVENT.laneParallel)
+    return `=== ${event.kind} ${terminalSafe(event.lane)} ${phasesText(event.phases)}`
+  if (event.kind === WATCH_EVENT.noTaskSignal) return `=== ${terminalSafe(noTaskSignalLine(event))}`
+  if (event.kind === WATCH_EVENT.laneStalled) return `=== ${terminalSafe(laneStalledLine(event))}`
+  return null
+}
+
 /**
  * The header line of one event: `=== merged #<number> (lane)`, `=== checks failed #<number> (lane|branch <name>): <checks> (<k> tests: <names>)`,
  * the checks and tests only when the event carries them,
@@ -167,14 +181,9 @@ export const watchEventLine = (event: WatchEvent, target: string | null): string
   if (event.kind === WATCH_EVENT.ghUnavailable) return `=== ${event.kind}: ${terminalSafe(event.reason)}`
   if (event.kind === WATCH_EVENT.preview)
     return `=== ${event.kind} #${event.number} (${terminalSafe(event.lane)}) ${terminalSafe(event.url)} · ${terminalSafe(event.headCommit.slice(0, SHORT_SHA_LENGTH))}`
-  if (event.kind === WATCH_EVENT.laneFill)
-    return `=== ${event.kind} ${terminalSafe(event.lane)} ${event.level} ${contextLabel(event.share)}`
-  if (event.kind === WATCH_EVENT.laneModel)
-    return `=== ${event.kind} ${terminalSafe(event.lane)} ${terminalSafe(event.model)} · board ${terminalSafe(event.column)}`
-  if (event.kind === WATCH_EVENT.laneParallel)
-    return `=== ${event.kind} ${terminalSafe(event.lane)} ${phasesText(event.phases)}`
+  const laneLine = laneEventLine(event)
+  if (laneLine !== null) return laneLine
   if (event.kind === WATCH_EVENT.taskParallel) return `=== ${terminalSafe(event.line)}`
-  if (event.kind === WATCH_EVENT.noTaskSignal) return `=== ${terminalSafe(noTaskSignalLine(event))}`
   if (event.kind === WATCH_EVENT.unlinkedArtifact) return `=== ${unlinkedArtifactLine(event)}`
   if (event.kind === WATCH_EVENT.approval)
     return `=== ${event.kind} ${terminalSafe(event.lane)} ${event.id} ${terminalSafe(event.tool)} · ${terminalSafe(event.summary)}`

package/src/watch/lane-stalled.ts

@@ -0,0 +1,59 @@
+import { MS_PER_MINUTE } from '../plan-format/clock'
+import { isRecord } from '../shared/is-record'
+
+export const LANE_STALLED_EVENT = 'stalled'
+
+/** How many heartbeat intervals a working lane's position stands still before it is reported. */
+export const STALLED_HEARTBEATS = 3
+
+/** What a heartbeat read of a lane: whether its agent works, and its position as the heartbeat shows it (`P12 7/12, 3 subagents`, `''` without one). */
+export type StallReading = { working: boolean; position: string }
+
+/** Per working lane: the position last read, since when it stands, and whether that stretch was reported. */
+export type StallState = Record<string, { position: string; since: number; reported: boolean }>
+
+export type LaneStalledEvent = { kind: typeof LANE_STALLED_EVENT; lane: string; minutes: number }
+
+type LaneEntry = StallState[string]
+
+const nextEntry = (previous: LaneEntry | undefined, position: string, now: number): LaneEntry =>
+  previous?.position === position ? previous : { position, since: now, reported: false }
+
+const standingMinutes = (entry: LaneEntry, now: number): number => Math.floor((now - entry.since) / MS_PER_MINUTE)
+
+/**
+ * The working lanes whose position (phase, ticks, subagents) stood still for `limitMinutes` or longer, one event per
+ * stretch: a moved position starts the clock again and may be reported again, a lane that stops working or has no
+ * reading drops its clock.
+ */
+export const laneStalledEvents = (
+  previous: StallState,
+  readings: Readonly<Record<string, StallReading>>,
+  now: number,
+  limitMinutes: number,
+): { events: LaneStalledEvent[]; state: StallState } => {
+  const events: LaneStalledEvent[] = []
+  const state: StallState = {}
+  for (const [lane, { working, position }] of Object.entries(readings)) {
+    if (!working) continue
+    const entry = nextEntry(previous[lane], position, now)
+    const minutes = standingMinutes(entry, now)
+    const due = !entry.reported && minutes >= limitMinutes
+    if (due) events.push({ kind: LANE_STALLED_EVENT, lane, minutes })
+    state[lane] = due ? { ...entry, reported: true } : entry
+  }
+  return { events, state }
+}
+
+/** The line the coordinator reads: `lane <name> stalled <n> min`. */
+export const laneStalledLine = ({ lane, minutes }: LaneStalledEvent): string =>
+  `lane ${lane} ${LANE_STALLED_EVENT} ${minutes} min`
+
+const isEntry = (value: unknown): boolean =>
+  isRecord(value) &&
+  typeof value.position === 'string' &&
+  typeof value.since === 'number' &&
+  typeof value.reported === 'boolean'
+
+export const isStallState = (value: unknown): value is StallState =>
+  isRecord(value) && Object.values(value).every(isEntry)

package/src/watch/watch-events.ts

@@ -14,6 +14,7 @@ import { emptyFeedbackState, FEEDBACK_EVENT, type FeedbackEvent, type FeedbackSt
 import { isLaneLevels, LANE_FILL_EVENT, type LaneFillEvent, type LaneLevels } from './lane-fill'
 import { isLaneModels, LANE_MODEL_EVENT, type LaneModelEvent, type LaneModels } from './lane-model'
 import { isLaneParallels, LANE_PARALLEL_EVENT, type LaneParallelEvent, type LaneParallels } from './lane-parallel'
+import { isStallState, LANE_STALLED_EVENT, type LaneStalledEvent, type StallState } from './lane-stalled'
 import { type LaneSnapshot, type SeenSeqs, seenSeqsOf } from './lane-watch'
 import { emptyPreviewState, isPreviewState, PREVIEW_EVENT, type PreviewEvent, type PreviewState } from './previews'
 import { PULL_REQUEST_STATE, type WatchedPullRequest } from './pull-requests'
@@ -57,6 +58,7 @@ export const WATCH_EVENT = {
   laneParallel: LANE_PARALLEL_EVENT,
   taskParallel: TASK_PARALLEL_EVENT,
   noTaskSignal: NO_TASK_SIGNAL_EVENT,
+  laneStalled: LANE_STALLED_EVENT,
   unlinkedArtifact: UNLINKED_ARTIFACT_EVENT,
   approval: APPROVAL_EVENT,
   source: SOURCE_EVENT,
@@ -116,6 +118,8 @@ export type WatchState = {
   parallelAutoEnded: string | null
   /** Per watched lane: since when it works without a task signal and the phase last reported as `no task signal`. */
   noTaskSignals: NoSignalState
+  /** Per working lane: its position at the last heartbeat, since when it stands and whether that was reported as `stalled`. */
+  laneStalls: StallState
   /** Per open artifact send no plan or board links: in its grace or already reported as `unlinked artifact`. */
   unlinkedArtifacts: UnlinkedState
   /** The ids of the approval requests on disk when they were last read, each reported once while it is open. */
@@ -179,6 +183,7 @@ export type WatchEvent =
   | LaneParallelEvent
   | TaskParallelEvent
   | NoTaskSignalEvent
+  | LaneStalledEvent
   | UnlinkedArtifactEvent
   | ApprovalEvent
   | SourceEvent
@@ -217,6 +222,7 @@ export const emptyWatchState = (): WatchState => ({
   taskParallels: {},
   parallelAutoEnded: null,
   noTaskSignals: {},
+  laneStalls: {},
   unlinkedArtifacts: {},
   approvals: [],
   sources: emptySourceState(),
@@ -269,6 +275,7 @@ const isWatchState = (value: Record<string, unknown>): value is WatchState =>
   isTaskParallelFingerprints(value.taskParallels) &&
   (value.parallelAutoEnded === null || typeof value.parallelAutoEnded === 'string') &&
   isNoSignalState(value.noTaskSignals) &&
+  isStallState(value.laneStalls) &&
   isUnlinkedState(value.unlinkedArtifacts) &&
   Array.isArray(value.approvals) &&
   value.approvals.every((id) => typeof id === 'string') &&