jackherd 1.12.5 → 1.12.7

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 What changed for people who use jackherd, newest first.
 
+## 1.12.7
+
+- **Newest first in the herd.** The rows of Your turn that wait on your answer (the board's open questions, a session's questions, the files and Artifacts sent to you) stand newest first; what frees a lane still comes before the rest, newest first within it. A since without a year counts in the year nearest to now, so a row of 31 December stands under one of 1 January. With more than five rows, the oldest are the ones under `▸ n more`. An opened source lists its entries newest first by the time each shows: before, an entry with its own time from the source (say, when an error was last seen) could stand among entries in the order the watcher saw them change. Rows of the same time keep their order. Appointments keep their order, the ones without a time first, then the next due.
+
+## 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.

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.5/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.7/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.5/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.7/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.5/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.7/assets/icons/space.svg">
 
 <p>
-<img src="https://unpkg.com/jackherd@1.12.5/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.7/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.5/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.7/assets/icons/space.svg">
 </p>
 
-<p><img src="https://unpkg.com/jackherd@1.12.5/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.7/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.5/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.7/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.5/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.7/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.5/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.7/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.5/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.7/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.5/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.5/assets/icons/space.svg"></p>
+<p><img src="https://unpkg.com/jackherd@1.12.7/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.7/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.5/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.7/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.5/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.7/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.5/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.7/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.5/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.7/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.5/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.7/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 |
 | --- | --- |
@@ -177,8 +177,8 @@ It has five blocks, top down. **Your turn** holds everything that waits on you,
 
 How the herd reads the board:
 
-- **Your turn** takes its rows from the board's open questions, the questions a session left in its dialog, the files and Artifacts sent to you, the board's appointments and its next section. What blocks a lane comes first, then the oldest; five rows show, then `▸ n more · k older than 7 days`. Appointments show for the next seven days, three of them, then `▸ n later`. `unblocks …` under a row names the lanes it frees (the board's Unblocks column). The head keeps the count, how many rows block lanes and the age of the oldest, folded too. At the selected row, `[ask]` asks Jack to put the question to you, `[done]` closes the row, `[run]` asks Jack to run an appointment now and `[move]` to ask you for a new time; enter never presses `[done]`. A row goes once its board row is closed or after `jh waiting close <id>`.
-- **Sources** shows, per source that is no ticket, its entries and how many are new, or when it last ran: amber with a new entry that is not in Your turn yet, red while it fails. Opened, a click on an entry opens it; `↑ in your turn` marks one a row of Your turn asks about.
+- **Your turn** takes its rows from the board's open questions, the questions a session left in its dialog, the files and Artifacts sent to you, the board's appointments and its next section. What blocks a lane comes first, then the newest; five rows show, then `▸ n more · k older than 7 days`. Appointments show for the next seven days, three of them, then `▸ n later`. `unblocks …` under a row names the lanes it frees (the board's Unblocks column). The head keeps the count, how many rows block lanes and the age of the oldest, folded too. At the selected row, `[ask]` asks Jack to put the question to you, `[done]` closes the row, `[run]` asks Jack to run an appointment now and `[move]` to ask you for a new time; enter never presses `[done]`. A row goes once its board row is closed or after `jh waiting close <id>`.
+- **Sources** shows, per source that is no ticket, its entries and how many are new, or when it last ran: amber with a new entry that is not in Your turn yet, red while it fails. Opened, its entries stand newest first by the time they show, and a click on an entry opens it; `↑ in your turn` marks one a row of Your turn asks about.
 - **Lanes** opens at the start. A lane that works or is blocked opens by itself only when it first appears; after that, opening and folding are yours. A lane symbol says the state (`●` working, `◆` blocked, `◉` the agent finished its answer, `○` idle, `(·) no agent` a worktree nobody works in); only blocked wears its word. A resting lane names what it waits on: `waits on you` with the open questions of its report, `waits on` a row of Your turn, `after` its board row's starts-after cell, or `idle · no reason`.
 - **Waiting** lists the lanes not started yet: no worktree yet, something left to do, and what each starts after; it starts folded. Finished lanes (cleaned up, or every phase they name ticked) are not shown.
 - **An open lane** shows, top down: its branch, the model and how long it idles; its link chips on one line, `+n` for the rest; its pull requests; the phases it works on, each with its bar and its first four open tasks, the running ones first, `▸ n more open · k done` to list them all; `▸ next` with the phases that wait, as ranges; `▸ done` with the finished ones. A lane shows only the phases its board rows name; a lane without a worktree reads its plan from the main checkout. A folded lane line names the phase moved last, `+n` more active ones and its count, and a reported task below it.

package/herdr-plugin/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "crossdelta.jackherd"
 name = "jackherd"
-version = "1.12.5"
+version = "1.12.7"
 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.5}"
+JACKHERD_VERSION="${JACKHERD_VERSION:-1.12.7}"
 
 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
@@ -221,9 +221,10 @@ twice.
   `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 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jackherd",
-  "version": "1.12.5",
+  "version": "1.12.7",
   "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/plans/your-turn.ts

@@ -2,6 +2,7 @@ import { DAY_MS, twoDigits } from '../plan-format/clock'
 import type { WaitingItem } from '../plan-format/waiting'
 import type { PlanLanguage } from '../vocabulary'
 import { parseAppointmentTime } from '../watch/appointments'
+import { newestFirst } from '../watch/newest-first'
 import { type AppointmentRow, appointmentRows, TIME_OPEN } from './appointment-rows'
 import { calendarDaysBetween } from './calendar-days'
 import { plain } from './markdown-text'
@@ -30,7 +31,7 @@ export type TurnRow = {
   appointment?: AppointmentRow
 }
 
-/** "Your turn": the now rows, what blocks a lane first, then the oldest; the planned rows, those without a time first. */
+/** "Your turn": the now rows, what blocks a lane first, then the newest; the planned rows, those without a time first. */
 export type YourTurn = { now: TurnRow[]; planned: TurnRow[] }
 
 /** "Your turn" as the herd draws it, with the clock (epoch milliseconds) its ages and the week ahead are counted from. */
@@ -140,9 +141,9 @@ const plannedFrom = (row: TurnRow | undefined, appointment: AppointmentRow): Tur
   return row ? { ...planned, unblocks: row.unblocks, ...(row.waiting ? { waiting: row.waiting } : {}) } : planned
 }
 
-const byBlockingThenAge = (left: TurnRow, right: TurnRow): number =>
-  Number(right.unblocks.length > 0) - Number(left.unblocks.length > 0) ||
-  (left.at ?? Number.POSITIVE_INFINITY) - (right.at ?? Number.POSITIVE_INFINITY)
+/** What frees a lane first (the orchestrate skill's `Unblocks` column), then the newest; equal rows keep their order. */
+const byBlockingThenNewest = (left: TurnRow, right: TurnRow): number =>
+  Number(right.unblocks.length > 0) - Number(left.unblocks.length > 0) || newestFirst(left.at, right.at)
 
 const byTime = (left: TurnRow, right: TurnRow): number =>
   (left.at ?? Number.NEGATIVE_INFINITY) - (right.at ?? Number.NEGATIVE_INFINITY)
@@ -169,7 +170,7 @@ export const yourTurnOf = ({ waiting, appointments, next, now }: TurnSources): Y
   }
   const shown = [...nowRows, ...planned]
   const nextRows = next.filter((text) => !shown.some((row) => sameTopic(topicText(row), text))).map(nextRowOf)
-  return { now: [...nowRows].sort(byBlockingThenAge), planned: [...planned, ...nextRows].sort(byTime) }
+  return { now: [...nowRows].sort(byBlockingThenNewest), planned: [...planned, ...nextRows].sort(byTime) }
 }
 
 /**

package/src/watch/newest-first.ts

@@ -0,0 +1,8 @@
+/**
+ * A sort comparator over two times in epoch milliseconds, newest first: a time nobody can read (null) goes after every
+ * time, and equal times (two nulls included) give 0, so the stable `Array.prototype.sort` keeps their order.
+ */
+export const newestFirst = (left: number | null, right: number | null): number => {
+  if (left === null || right === null) return Number(left === null) - Number(right === null)
+  return right - left
+}

package/src/watch/source-statuses.ts

@@ -1,3 +1,4 @@
+import { newestFirst } from './newest-first'
 import { isFresh, NEW_FOR_MS } from './plan-badges'
 import { previewUrlOf } from './previews'
 import { lineText, type SourceEntry, type SourceRecord } from './sources'
@@ -16,7 +17,7 @@ export type EntryStatus = {
   isNew: boolean
 }
 
-/** What the herd shows of a source: when it ran last, since when it fails, its newest report and its entries, newest change first. */
+/** What the herd shows of a source: when it ran last, since when it fails, its newest report and its entries, newest first by the time each shows. */
 export type SourceStatus = {
   name: string
   ranAt: number | null
@@ -48,7 +49,9 @@ const statusOf = (name: string, record: SourceRecord | undefined, now: number):
   ranAt: record?.ranAt ?? null,
   failingSince: record?.failingSince ?? null,
   latest: latestOf(record?.latest, now),
-  entries: (record?.entries ?? []).map((entry) => entryStatusOf(entry, now)),
+  entries: (record?.entries ?? [])
+    .map((entry) => entryStatusOf(entry, now))
+    .sort((left, right) => newestFirst(left.at, right.at)),
 })
 
 /**