jackherd 1.6.0 → 1.7.0

package/src/plans/ensure-panes.ts

@@ -40,14 +40,14 @@ const apply = (action: PaneAction): string => {
         ? splitPaneOf(runHerdr(['pane', 'split', action.pane, '--direction', 'right', '--no-focus']))
         : action.pane
     runHerdr(['pane', 'run', target, action.command])
-    return `${action.kind === 'split' ? `split ${action.pane}, ` : ''}started the plans view in ${target}`
+    return `${action.kind === 'split' ? `split ${action.pane}, ` : ''}started the herd in ${target}`
   } catch (error) {
     return `${action.pane}: ${errorText(error)}`
   }
 }
 
 /**
- * `plans --ensure`: brings back every missing plans view beside the coordinator and each lane of the board, and
+ * `herd --ensure`: brings back every missing herd pane beside the coordinator and each lane of the board, and
  * leaves running ones alone, so it can run after every start. A lane gets its view once its agent runs. One line per
  * action or skipped target, none when every view runs.
  */

package/src/plans/herd-command.ts

@@ -0,0 +1,4 @@
+/** The CLI word of the herd and the alias it had up to 1.6, which running panes of that version still carry. */
+export const HERD_COMMAND = { name: 'herd', alias: 'plans' } as const
+
+export const HERD_COMMAND_WORDS: readonly string[] = Object.values(HERD_COMMAND)

package/src/plans/lane-discovery.ts

@@ -9,14 +9,26 @@ export type LaneSources = {
 
 export type LaneSetChange = { added: string[]; removed: string[] }
 
+/**
+ * The helper agents of the lanes: an agent named `<lane>-<purpose>` that a lane started in a pane of its own, such as
+ * for a measurement. A name that is a worktree of its own is that lane, not a helper. The prefix only decides whether
+ * the agent is watched, not whose it is: under lanes `a` and `a-b` the agent `a-b-c` matches both and is watched once,
+ * and any agent named after a lane with a suffix is watched, whoever started it.
+ */
+const helpersOf = (lanes: readonly string[], worktrees: readonly string[], agentNames: readonly string[]): string[] =>
+  [...new Set(agentNames)].filter(
+    (name) => !worktrees.includes(name) && lanes.some((lane) => name.startsWith(`${lane}-`)),
+  )
+
 /**
  * The lanes to watch when none are named: a worktree directory whose name a herdr agent carries or
  * the board's lanes table lists. A worktree with neither (a branch parked in its own checkout) is no
- * lane, and an agent or a row without a worktree is none either.
+ * lane, and an agent or a row without a worktree is none either, except a lane's helper agent (`helpersOf`).
  */
 export const discoverLanes = ({ worktrees, agentNames, sprintLanes }: LaneSources): string[] => {
   const claimed = new Set([...agentNames, ...sprintLanes])
-  return [...new Set(worktrees)].filter((worktree) => claimed.has(worktree)).sort()
+  const lanes = [...new Set(worktrees)].filter((worktree) => claimed.has(worktree))
+  return [...lanes, ...helpersOf(lanes, worktrees, agentNames)].sort()
 }
 
 /** The lanes that joined and left between two discoveries, each sorted. */

package/src/plans/lane-tickets.ts

@@ -0,0 +1,69 @@
+import type { SprintLane } from '../plan-format'
+import type { SourceTicket, TicketBadge } from '../watch/plan-badges'
+import type { LinkChip } from './link-chips'
+import { shownWithMore } from './shown-with-more'
+
+/** The tickets of one lane as drawn: the first `SHOWN_TICKETS`, how many more, and how many of all are new. */
+export type LaneTickets = { shown: TicketBadge[]; more: number; newCount: number }
+
+export const SHOWN_TICKETS = 3
+
+const WORD_CHARACTER = /[\p{L}\p{N}_]/u
+
+const isWordCharacter = (character: string | undefined): boolean =>
+  character !== undefined && WORD_CHARACTER.test(character)
+
+/**
+ * Whether `text` names `id` as a whole word: no letter, digit or `_` right before or after it, so `T-12` is not
+ * found in `T-123`. A plain search per occurrence, no regular expression: a lookbehind over a long plan cost
+ * seconds per refresh. An empty id is found nowhere.
+ */
+const namesWord = (text: string, id: string): boolean => {
+  if (id === '') return false
+  for (let at = text.indexOf(id); at !== -1; at = text.indexOf(id, at + 1)) {
+    if (!isWordCharacter(text[at - 1]) && !isWordCharacter(text[at + id.length])) return true
+  }
+  return false
+}
+
+const belongsTo = (ticket: SourceTicket, lane: string, texts: readonly string[]): boolean =>
+  ticket.lane === lane || [lane, ...texts].some((text) => namesWord(text, ticket.id))
+
+const onceById = (tickets: readonly SourceTicket[]): SourceTicket[] =>
+  tickets.filter((ticket, index) => tickets.findIndex(({ id }) => id === ticket.id) === index)
+
+const badgeOf = ({ lane: _lane, ...badge }: SourceTicket): TicketBadge => badge
+
+/** What the lane's board rows say of it beside its name, for finding ticket ids: the text of each row. */
+export const boardRowTexts = (lane: SprintLane): string[] => lane.steps.map(({ label }) => label)
+
+/**
+ * The tickets of `lane`: those of a source that names it, and those whose id the lane's name or `texts` (its board
+ * rows and its plans) name as a whole word, as written. A ticket listed twice counts once, from its first source.
+ * New tickets come first, the rest keep their order; null when the lane has none, so the view draws nothing.
+ */
+export const laneTicketsOf = (
+  tickets: readonly SourceTicket[],
+  lane: string,
+  texts: readonly string[],
+): LaneTickets | null => {
+  const own = onceById(tickets.filter((ticket) => belongsTo(ticket, lane, texts))).map(badgeOf)
+  if (own.length === 0) return null
+  const fresh = own.filter(({ isNew }) => isNew)
+  const ordered = [...fresh, ...own.filter(({ isNew }) => !isNew)]
+  return {
+    ...shownWithMore(ordered, SHOWN_TICKETS),
+    newCount: fresh.length,
+  }
+}
+
+/** The lane's link chips without those whose URL a shown ticket badge opens: the badge takes the chip's place. */
+export const withoutTicketLinks = (
+  chips: Record<string, LinkChip[]>,
+  tickets: LaneTickets,
+): Record<string, LinkChip[]> => {
+  const shown = new Set(tickets.shown.flatMap(({ url }) => (url ? [url] : [])))
+  return Object.fromEntries(
+    Object.entries(chips).map(([href, list]) => [href, list.filter(({ url }) => !shown.has(url))]),
+  )
+}

package/src/plans/layout.ts

@@ -1,12 +1,13 @@
 import { CONTEXT_LEVEL, type ContextLevel, type ContextReading, contextLabel } from '../context'
-import type { ChecklistItem, DeferredItem, LaneProgress, PhaseProgress, PlanStep, StepProgress } from '../plan-format'
-import { activeItem, currentPhase, isTickedUnmerged, PHASE_ID_PREFIX } from '../plan-format'
+import type { ChecklistItem, DeferredItem, LaneProgress, PhaseProgress, StepProgress } from '../plan-format'
+import { activeItem, currentPhase, isTickedUnmerged, onlyDocumentationOpen, PHASE_ID_PREFIX } from '../plan-format'
 import {
   BADGE_TONE,
   BAR_SEGMENT,
   type BadgeTone,
   badge,
   bar,
+  box,
   fit,
   INVERSE_ON,
   packGroups,
@@ -24,12 +25,15 @@ import { PLAN_LANGUAGE, type PlanLanguage } from '../vocabulary'
 import {
   NO_BADGES,
   type PullRequestBadges,
+  type TicketBadge,
   WATCH_HEALTH,
   type WatchBadges,
   type WatchHealth,
 } from '../watch/plan-badges'
 import { LANE_STANDING, type LaneStanding, laneStanding, waitingNote } from './lane-standing'
-import { chipKey, type LinkChip } from './link-chips'
+import type { LaneTickets } from './lane-tickets'
+import { chipKey, type LinkChip, planUrlOf } from './link-chips'
+import { type PhaseModel, phaseModelKey } from './phase-models'
 import { type PlannedPlan, phaseList, plannedPhaseCount } from './planned'
 import { CHECKS, type ChecksState, type PullRequest, pullRequestKey } from './pull-requests'
 import {
@@ -38,7 +42,6 @@ import {
   isLaneOpen,
   itemKey,
   laneKey,
-  notesKey,
   PLANNED_KEY,
   phaseKey,
   type Selection,
@@ -46,8 +49,10 @@ import {
   targetKeys,
   tickedKey,
 } from './selection'
+import { shownWithMore } from './shown-with-more'
 import {
   chevronOf,
+  MODEL_MARK,
   NO_AGENT_SYMBOL,
   NO_AGENT_WORD,
   PHASE_COUNT,
@@ -57,7 +62,7 @@ import {
   statusSymbol,
   statusWord,
 } from './symbols'
-import { BADGE_TEXTS, type BadgeTexts, laneMarkText, TEXTS } from './texts'
+import { BADGE_TEXTS, type BadgeTexts, checksText, laneMarkText, TEXTS } from './texts'
 
 /**
  * Where a lane stands outside its plan. `agent` is the terminal adapter's status, null when no agent is listed;
@@ -82,6 +87,10 @@ export type LaneView = {
   unlisted?: boolean
   /** Preview and feedback of the lane's pull requests from the running watcher's state; none without a watcher. */
   badges?: WatchBadges
+  /** The tickets of the lane from the running watcher's state; absent when it has none or no watcher runs. */
+  tickets?: LaneTickets
+  /** The model each phase's implementing subagent last ran on, by `phaseModelKey`; absent without a record. */
+  models?: Record<string, PhaseModel>
 }
 
 /**
@@ -94,6 +103,8 @@ export type OverviewView = {
   lanes: LaneView[]
   planned: PlannedPlan[]
   watch?: WatchHealth
+  /** True when the config marks a ticket source, so a missing watcher is said without a pull request too. */
+  watchesTickets?: boolean
   language?: PlanLanguage
 }
 
@@ -114,6 +125,10 @@ type LaneContext = {
   chips: Record<string, LinkChip[]>
   badges: WatchBadges
   badgeTexts: BadgeTexts
+  /** The lane's tickets for the plan block that shows them, the first; null in every other block. */
+  tickets: LaneTickets | null
+  /** The model each phase ran on, by `phaseModelKey`. */
+  models: Record<string, PhaseModel>
 }
 
 /**
@@ -143,20 +158,24 @@ const TREE_GUTTER = TREE.branch.length
 
 /** Places on each side of the slash of a count: `  9/9  `, ` 15/15 `, `123/456`. */
 const COUNT_PLACES = 3
-/** The cells before a count: `✅`, `✓`, `?`, `–` or nothing, padded so every slash on screen is in one column. */
+/** The cells before a count: `◐`, `✓`, `?`, `–` or nothing, padded so every slash on screen is in one column. */
 const COUNT_MARK_WIDTH = 2
 const BLANK_COUNT = ' '.repeat(2 * COUNT_PLACES + 1)
 const MIN_TITLE_WIDTH = 8
 const MIN_BESIDE_WIDTH = 24
 const CONTEXT_WIDTH = 5
-const CONTEXT_SYMBOL = '🧠'
-const PROGRESS_SYMBOL = '✅'
+const CONTEXT_SYMBOL = '🥣'
+const PROGRESS_SYMBOL = '◐'
+const HEADER_MARK = '🐾'
 const COLUMN_RULE = '│'
 /** The number badge of a three-digit pull request (`↗ #` and the digits, a cell of padding either side); a longer one widens it. */
 const PULL_REQUEST_BADGE_WIDTH = 8
 /** Under the lane line's status symbol, where the pull request row and its badge line start (D96). */
 const PULL_REQUEST_INDENT = '  '
 const CHECKS_WIDTH = 10
+/** The most failed tests listed under a pull request; the rest is counted. */
+const SHOWN_FAILED_TESTS = 3
+const FAILED_TEST_INDENT = '     '
 const MARKDOWN_MARKS = /\*\*|`/g
 
 /** Lower ranks need the coordinator sooner; a status an adapter adds later ranks after `working`. */
@@ -169,10 +188,11 @@ const URGENCY: Record<AgentStatus, number> = {
 const UNKNOWN_URGENCY = 3
 const NO_AGENT_URGENCY = 4
 
-const AGENT_PAINT: Record<AgentStatus, (text: string) => string> = {
-  [AGENT_STATUS.working]: paint.yellow,
-  [AGENT_STATUS.blocked]: paint.red,
-  [AGENT_STATUS.done]: paint.green,
+/** The colour of a lane state, word and symbol alike: teal while working or done, bold amber when it waits for you, grey when idle. */
+const STATUS_PAINT: Record<AgentStatus, (text: string) => string> = {
+  [AGENT_STATUS.working]: paint.teal,
+  [AGENT_STATUS.blocked]: (text) => paint.bold(paint.yellow(text)),
+  [AGENT_STATUS.done]: paint.teal,
   [AGENT_STATUS.idle]: paint.dim,
 }
 
@@ -207,19 +227,28 @@ const PHASE_PAINT: Record<PhaseState, (count: string) => string> = {
 const countText = (done: number, total: number): string =>
   `${String(done).padStart(COUNT_PLACES)}/${String(total).padEnd(COUNT_PLACES)}`
 
+const COUNT_CELL_WIDTH = COUNT_MARK_WIDTH + 1 + BLANK_COUNT.length
+
 /** Mark and count in one fixed-width cell at the right edge, the same for the lane, phase and planned rows. */
 const countCell = (mark: string, count: string): string => `${padVisible(mark, COUNT_MARK_WIDTH)} ${count}`
 
+/** A word in place of a count, right-aligned in the width of the count cell like `n/m`. */
+const wordCell = (word: string): string => `${' '.repeat(Math.max(COUNT_CELL_WIDTH - textWidth(word), 0))}${word}`
+
 const PHASE_MARK: Record<PhaseState, string> = {
   [PHASE_STATE.missing]: PHASE_COUNT.missing,
   [PHASE_STATE.empty]: PHASE_COUNT.empty,
-  [PHASE_STATE.all]: PHASE_COUNT.allTicked,
+  [PHASE_STATE.all]: '',
   [PHASE_STATE.open]: '',
 }
 
-/** The count cell of a phase row at the right edge; the current phase is bold yellow. */
+/** The count cell of a phase row at the right edge; the current phase is bold yellow. A phase lacking only the documentation box says so instead of a count. */
 const phaseCountCell = (phase: PhaseProgress, current: boolean): string => {
   const state = phaseStateOf(phase)
+  if (state === PHASE_STATE.open && onlyDocumentationOpen(phase)) {
+    const cell = wordCell(TEXTS.allButDocs)
+    return current ? paint.bold(paint.yellow(cell)) : paint.green(cell)
+  }
   const hasCount = state === PHASE_STATE.open || state === PHASE_STATE.all
   const cell = countCell(PHASE_MARK[state], hasCount ? countText(phase.done, phase.total) : BLANK_COUNT)
   return current ? paint.bold(paint.yellow(cell)) : PHASE_PAINT[state](cell)
@@ -227,13 +256,16 @@ const phaseCountCell = (phase: PhaseProgress, current: boolean): string => {
 
 const agentLabel = (agent: string | null): string => {
   if (agent === null) return paint.dim(statusWord(agent))
-  return isAgentStatus(agent) ? AGENT_PAINT[agent](statusWord(agent)) : statusWord(agent)
+  return isAgentStatus(agent) ? STATUS_PAINT[agent](statusWord(agent)) : statusWord(agent)
 }
 
 /** The symbol of a status padded to `SYMBOL_WIDTH` cells, so the names after it start in one column. */
 const symbolCell = (agent: string | null): string => {
   const symbol = statusSymbol(agent)
-  return padVisible(agent === null ? paint.dim(symbol) : symbol, SYMBOL_WIDTH)
+  return padVisible(
+    agent !== null && isAgentStatus(agent) ? STATUS_PAINT[agent](symbol) : paint.dim(symbol),
+    SYMBOL_WIDTH,
+  )
 }
 
 const aheadLabel = ({ branch, ahead }: LaneStatus): string => {
@@ -431,11 +463,39 @@ export const rowWithCount = (
 const unmergedMark = (phase: PhaseProgress): string =>
   isTickedUnmerged(phase) ? ` ${paint.yellow(TEXTS.tickedUnmerged)}` : ''
 
-/** The phase title cut before the count, which stays at the right edge, or the note that the plan lacks the phase. */
-const phaseRow = (phase: PhaseProgress, open: boolean, current: boolean, width: number): string => {
+/** The chevron of a phase row; a finished phase that is closed shows a green ✓ in its place. */
+const phaseMark = (phase: PhaseProgress, open: boolean): string =>
+  !open && phaseStateOf(phase) === PHASE_STATE.all ? paint.green(PHASE_COUNT.allTicked) : paint.dim(chevronOf(open))
+
+const familyLabel = (family: string): string => `${family.charAt(0).toUpperCase()}${family.slice(1)}`
+
+/**
+ * The model the phase's subagent last ran on: `Opus ✓` when it fits the plan's recommendation, `Sonnet ≠ Opus` in
+ * amber when it does not, the family alone, dim, when the plan recommends none; empty without a record.
+ */
+const modelMark = (model: PhaseModel | undefined): string => {
+  if (!model) return ''
+  const used = familyLabel(model.used)
+  if (model.recommended === null) return paint.dim(used)
+  return model.fits
+    ? `${paint.dim(used)} ${paint.green(MODEL_MARK.fits)}`
+    : paint.yellow(`${used} ${MODEL_MARK.differs} ${familyLabel(model.recommended)}`)
+}
+
+/**
+ * The phase title cut before the model and the count, which stay at the right edge, or the note that the plan lacks
+ * the phase. The model gives way in a pane too narrow to leave the title `MIN_TITLE_WIDTH` cells.
+ */
+const phaseRow = (phase: PhaseProgress, open: boolean, current: boolean, width: number, model?: PhaseModel): string => {
   const title = phase.title === null ? paint.dim(TEXTS.notInPlan) : plain(phase.title)
-  const head = `${paint.dim(chevronOf(open))} P${phase.id} ${title}${current ? unmergedMark(phase) : ''}`
-  return spread(head, phaseCountCell(phase, current), width)
+  const label = `${phaseMark(phase, open)} P${phase.id} `
+  const head = `${label}${title}${current ? unmergedMark(phase) : ''}`
+  const count = phaseCountCell(phase, current)
+  const withModel = `${modelMark(model)}${COLUMN_SEPARATOR}${count}`
+  const titleRoom = width - visibleLength(label) - visibleLength(withModel) - 1
+  const fitsModel =
+    model !== undefined && (titleRoom >= MIN_TITLE_WIDTH || titleRoom >= visibleLength(head) - visibleLength(label))
+  return spread(head, fitsModel ? withModel : count, width)
 }
 
 /** A closed phase shows only `active` under it, when given, closed whatever the task's fold. */
@@ -459,7 +519,8 @@ const phaseFrame = (context: StepContext, phase: PhaseProgress): Frame => {
   const inner = deeper(context)
   const active = current ? activeItem(phase) : null
   const children = open ? phaseChildren(inner, key, phase, active) : [activeTaskFrame(inner, key, phase, active)]
-  return joinFrames([rowFrame(key, [phaseRow(phase, open, current, width)], [], context), nest(children)])
+  const model = context.models[phaseModelKey(stepIndex, phase.id)]
+  return joinFrames([rowFrame(key, [phaseRow(phase, open, current, width, model)], [], context), nest(children)])
 }
 
 /** True when number, checks and the badges leave room for a title beside them on one line. */
@@ -471,9 +532,12 @@ const fitsBeside = (head: string, cells: BadgeCell[], width: number): boolean =>
  * columns, the watcher's badges after them and the title last, cut with `…` on its one line. When the badges leave no
  * room for a title, they go on lines of their own below, starting in the column of the lane's status symbol (D96).
  */
-const pullRequestFrame = (pullRequest: PullRequest, context: LaneContext): Frame => {
+const pullRequestRow = (pullRequest: PullRequest, context: LaneContext): Frame => {
   const number = padVisible(badge(pullRequest.url, `↗ #${pullRequest.number}`), PULL_REQUEST_BADGE_WIDTH)
-  const checks = padVisible(CHECKS_PAINT[pullRequest.checks](TEXTS.checks[pullRequest.checks]), CHECKS_WIDTH)
+  const checksWords = checksText(pullRequest)
+  const checksColumn =
+    textWidth(checksWords) < CHECKS_WIDTH ? CHECKS_WIDTH : textWidth(checksWords) + COLUMN_SEPARATOR.length
+  const checks = padVisible(CHECKS_PAINT[pullRequest.checks](checksWords), checksColumn)
   const head = `${PULL_REQUEST_INDENT}${number}${COLUMN_SEPARATOR}${checks}`
   const prefix = pullRequest.draft ? TEXTS.draft : ''
   const dimPrefix = (line: string, index: number) =>
@@ -495,6 +559,23 @@ const pullRequestFrame = (pullRequest: PullRequest, context: LaneContext): Frame
   return { ...row, targets: [...cellTargets(cells, 0, visibleLength(head), context.width), ...row.targets] }
 }
 
+/** The failed tests of a red pull request, at most `SHOWN_FAILED_TESTS` of them one per line, then `+<n>`; none otherwise. */
+const failedTestLines = (pullRequest: PullRequest, badges: PullRequestBadges | undefined, width: number): string[] => {
+  const tests = pullRequest.checks === CHECKS.failed ? (badges?.failedTests ?? []) : []
+  const { shown, more } = shownWithMore(tests, SHOWN_FAILED_TESTS)
+  const lines = shown.map((name) => `${FAILED_TEST_INDENT}${paint.red(`✗ ${plain(name)}`)}`)
+  return [...lines, ...(more > 0 ? [`${FAILED_TEST_INDENT}${paint.dim(`+${more}`)}`] : [])].map((line) =>
+    fit(line, width),
+  )
+}
+
+/** The pull request row, then the tests its red checks failed, which only the watcher knows. */
+const pullRequestFrame = (pullRequest: PullRequest, context: LaneContext): Frame =>
+  joinFrames([
+    pullRequestRow(pullRequest, context),
+    textFrame(failedTestLines(pullRequest, context.badges[String(pullRequest.number)], context.width)),
+  ])
+
 const CONTEXT_PAINT: Record<ContextLevel, (text: string) => string> = {
   [CONTEXT_LEVEL.ok]: paint.dim,
   [CONTEXT_LEVEL.warn]: paint.yellow,
@@ -521,26 +602,17 @@ const groupSteps = (steps: readonly StepProgress[]): number[][] =>
     return groups
   }, [])
 
-const isTicked = ({ phase }: PhaseEntry): boolean => phase.total > 0 && phase.done === phase.total
-
-/** A ticked phase folds into the ticked line, unless it is the current one: that one stays a row of its own. */
-const foldsAway = (progress: LaneProgress, entry: PhaseEntry): boolean =>
-  isTicked(entry) && !isCurrent(progress, entry.stepIndex, entry.phase)
-
-const tickedLine = (entries: PhaseEntry[]): string[] =>
-  entries.length === 0
-    ? []
-    : [`${paint.green('✓')} ${paint.dim(`${entries.map(({ phase }) => `P${phase.id}`).join(' ')} ${TEXTS.ticked}`)}`]
-
 const CHIP_GAP = ' '
 const CHIP_MARK = '📎 '
+const TICKET_MARK = '📡'
+const STATUS_SEPARATOR = ' · '
 
 /** `✦ label` as a badge linked to the chip's address, `private` faint after it for a link its plan says is private. */
 const chipCell = ({ url, icon, label, private: hidden }: LinkChip): string =>
   badge(url, `${icon} ${plain(label)}`, hidden ? TEXTS.privateLink : '')
 
-/** A badge and the key a click on it opens. */
-type BadgeCell = { cell: string; key: string }
+/** A badge and the key a click on it opens; null for a cell no click opens. */
+type BadgeCell = { cell: string; key: string | null }
 
 const packedWidth = (cells: BadgeCell[]): number =>
   cells.reduce((sum, { cell }, index) => sum + visibleLength(cell) + (index > 0 ? CHIP_GAP.length : 0), 0)
@@ -548,8 +620,9 @@ const packedWidth = (cells: BadgeCell[]): number =>
 /** One click target per badge of a line, from `column` on, each over exactly the columns it covers up to `edge`. */
 const cellTargets = (cells: BadgeCell[], line: number, column: number, edge: number): ClickTarget[] => {
   let from = column
-  return cells.map(({ cell, key }) => {
-    const target = { line, from, to: Math.min(from + visibleLength(cell), edge), key }
+  return cells.flatMap(({ cell, key }) => {
+    const to = Math.min(from + visibleLength(cell), edge)
+    const target = key === null ? [] : [{ line, from, to, key }]
     from += visibleLength(cell) + CHIP_GAP.length
     return target
   })
@@ -578,13 +651,36 @@ const packedFrame = (cells: BadgeCell[], lead: string, width: number): Frame =>
   return { lines, cursorLine: -1, targets }
 }
 
-/** The chips of a plan behind a 📎, then a blank line before the phases. */
-const chipFrame = (chips: LinkChip[], width: number): Frame => {
-  const frame = packedFrame(
-    chips.map((chip) => ({ cell: chipCell(chip), key: chipKey(chip.url) })),
-    CHIP_MARK,
-    width,
-  )
+const ticketTone = (isNew: boolean): BadgeTone => (isNew ? BADGE_TONE.amber : BADGE_TONE.grey)
+
+/** A badge linked to `url`, or a box no click opens when there is none. */
+const linkedBox = (url: string | null, text: string, tone: BadgeTone): string =>
+  url ? badge(url, text, '', tone) : box(text, tone)
+
+/** `📡 T-1 · In Progress` linked to the ticket, amber while new; a ticket without URL is a box no click opens. */
+const ticketCell = ({ id, url, status, isNew }: TicketBadge): BadgeCell => {
+  const text = `${TICKET_MARK} ${id}${status ? `${STATUS_SEPARATOR}${status}` : ''}`
+  return { cell: linkedBox(url, text, ticketTone(isNew)), key: url ? chipKey(url) : null }
+}
+
+/** The lane's ticket badges, then `+<n>` as plain text for the ones not shown. */
+const ticketCells = (tickets: LaneTickets | null): BadgeCell[] => {
+  if (!tickets) return []
+  const more = tickets.more > 0 ? [{ cell: paint.dim(`+${tickets.more}`), key: null }] : []
+  return [...tickets.shown.map(ticketCell), ...more]
+}
+
+const chipCellOf = (chip: LinkChip): BadgeCell => ({ cell: chipCell(chip), key: chipKey(chip.url) })
+
+/** The chips of a plan behind a 📎, the plan chip first and the tickets beside it, then a blank line before the phases. */
+const chipFrame = (chips: LinkChip[], tickets: LaneTickets | null, width: number): Frame => {
+  const isPlanChip = (chip: LinkChip) => planUrlOf(chipKey(chip.url)) !== null
+  const cells = [
+    ...chips.filter(isPlanChip).map(chipCellOf),
+    ...ticketCells(tickets),
+    ...chips.filter((chip) => !isPlanChip(chip)).map(chipCellOf),
+  ]
+  const frame = packedFrame(cells, CHIP_MARK, width)
   return frame.lines.length > 0 ? { ...frame, lines: [...frame.lines, ''] } : frame
 }
 
@@ -612,43 +708,22 @@ const badgeCells = (
 const planHeading = (title: string, width: number): string[] => wrap(plain(title), width).map(paint.bold)
 
 /**
- * A plan as a node: its title in bold, and below it the links, the open phases, and the ticked ones summed up in
- * one line unless `showDone` lists them.
+ * A plan as a node: its title in bold, and below it the links and the phases in plan order, each ticked one as a
+ * collapsed row of its own.
  */
 const planBlock = (context: LaneContext, stepIndexes: number[], entries: PhaseEntry[]): Frame => {
-  const { progress, state, width, chips } = context
+  const { progress, width, chips, tickets } = context
   const { planTitle, planHref } = progress.steps[stepIndexes[0]].step
-  const shown = state.showDone ? entries : entries.filter((entry) => !foldsAway(progress, entry))
-  const ticked = state.showDone ? [] : entries.filter((entry) => foldsAway(progress, entry))
   const inner = deeper(context)
   return joinFrames([
     textFrame(planHeading(planTitle, width)),
     nest([
-      chipFrame(planHref ? (chips[planHref] ?? []) : [], inner.width),
-      ...shown.map(({ stepIndex, phase }) => phaseFrame({ ...inner, stepIndex }, phase)),
-      textFrame(tickedLine(ticked)),
+      chipFrame(planHref ? (chips[planHref] ?? []) : [], tickets, inner.width),
+      ...entries.map(({ stepIndex, phase }) => phaseFrame({ ...inner, stepIndex }, phase)),
     ]),
   ])
 }
 
-/**
- * The summary line of a lane's notes is a row of its own, clickable like the key `n`; shown, the notes follow it
- * unselectable.
- */
-const noteFrame = (context: LaneContext, steps: PlanStep[]): Frame => {
-  if (steps.length === 0) return textFrame([])
-  const { progress, state, width } = context
-  const lane = progress.lane.name
-  const shown = state.notesShown.has(lane)
-  const summary = paint.dim(
-    `${chevronOf(shown)} ${shown ? TEXTS.notesShown(steps.length) : TEXTS.notesHidden(steps.length)}`,
-  )
-  const notes = shown
-    ? steps.flatMap((step) => [...planHeading(step.planTitle, width), ...wrap(plain(step.label), width).map(paint.dim)])
-    : []
-  return rowFrame(notesKey(lane), [fit(summary, width)], notes, context)
-}
-
 /** The columns lane lines share, so names, statuses and bars of all of them line up. */
 const STATUS_WIDTH = Math.max(...[...Object.values(AGENT_STATUS), NO_AGENT_WORD].map(textWidth))
 
@@ -674,8 +749,16 @@ const pullRequestMark = (pullRequest: PullRequest, badges: WatchBadges): string
   return badge(pullRequest.url, text, '', markTone(found))
 }
 
-const pullRequestMarks = ({ pullRequests, badges }: LaneView): string =>
-  pullRequests.map((pullRequest) => pullRequestMark(pullRequest, badges ?? {})).join(' ')
+/** `📡 <n>` in amber while tickets of the lane are new, linked to the first of them; nothing otherwise. */
+const ticketMark = (tickets: LaneTickets | undefined): string[] => {
+  const first = tickets?.shown.find(({ isNew }) => isNew)
+  if (!tickets || !first) return []
+  return [linkedBox(first.url, `${TICKET_MARK} ${tickets.newCount}`, BADGE_TONE.amber)]
+}
+
+/** A folded lane's marks: its pull request badges, and the ticket mark while a ticket is new. */
+const laneMarks = ({ pullRequests, badges, tickets }: LaneView): string =>
+  [...pullRequests.map((pullRequest) => pullRequestMark(pullRequest, badges ?? {})), ...ticketMark(tickets)].join(' ')
 
 /** What follows the status on a lane line: git state while the lane is open, the next phase when folded. */
 const laneDetail = (view: LaneView, open: boolean): string => {
@@ -702,10 +785,10 @@ const laneRight = (view: LaneView): string => {
   return counts ? `${contextCell(view.context)}${counts}` : contextCell(view.context).trimEnd()
 }
 
-/** A folded lane's pull request badges in the column of `columns.marks`, right before context and bar (D96). */
+/** A folded lane's marks in the column of `columns.marks`, right before context and bar (D96). */
 const markedRight = (view: LaneView, columns: LaneColumns): string => {
   const right = laneRight(view)
-  const marks = pullRequestMarks(view)
+  const marks = laneMarks(view)
   if (!marks) return right
   if (columns.right === 0) return padVisible(marks, columns.marks)
   const pad = ' '.repeat(Math.max(columns.right - visibleLength(right), 0))
@@ -731,7 +814,16 @@ const laneBlock = (
   columns: LaneColumns,
   badgeTexts: BadgeTexts,
 ): Frame => {
-  const context = { progress: view.progress, state, width, chips: view.chips, badges: view.badges ?? {}, badgeTexts }
+  const context = {
+    progress: view.progress,
+    state,
+    width,
+    chips: view.chips,
+    badges: view.badges ?? {},
+    badgeTexts,
+    tickets: view.tickets ?? null,
+    models: view.models ?? {},
+  }
   const open = isLaneOpen(state, view.progress.lane.name, view.status.agent)
   const row = rowFrame(laneKey(view.progress.lane.name), laneLines(view, open, width, columns), [], context)
   if (!open) return row
@@ -742,13 +834,12 @@ const laneBlock = (
     ),
   }))
   const planned = groups.filter(({ entries }) => entries.length > 0)
-  const notes = groups
-    .filter(({ entries }) => entries.length === 0)
-    .map(({ stepIndexes }) => view.progress.steps[stepIndexes[0]].step)
   const inner = deeper(context)
   const content = nestSpaced([
-    ...planned.map(({ stepIndexes, entries }) => planBlock(inner, stepIndexes, entries)),
-    noteFrame(inner, notes),
+    ...(planned.length === 0 ? [chipFrame([], inner.tickets, inner.width)] : []),
+    ...planned.map(({ stepIndexes, entries }, index) =>
+      planBlock(index === 0 ? inner : { ...inner, tickets: null }, stepIndexes, entries),
+    ),
     followingFrame(view, state, inner.width),
   ])
   return joinFrames([row, ...view.pullRequests.map((pullRequest) => pullRequestFrame(pullRequest, context)), content])
@@ -833,17 +924,20 @@ const separate = (blocks: Frame[], width: number): Frame[] =>
 
 /**
  * Why badges may be missing, said beside the clock: no watcher runs, or its state is stale. Nothing while it is live,
- * or when no lane on screen has a pull request a badge could belong to.
+ * or when no lane on screen has a pull request a badge could belong to and no source is marked `ticket`.
  */
-const watchNotice = (lanes: LaneView[], watch: WatchHealth | undefined, texts: BadgeTexts): string => {
+const watchNotice = (
+  { lanes, watch, watchesTickets }: Pick<OverviewView, 'lanes' | 'watch' | 'watchesTickets'>,
+  texts: BadgeTexts,
+): string => {
   if (!watch || watch.kind === WATCH_HEALTH.live) return ''
-  if (!lanes.some(({ pullRequests }) => pullRequests.length > 0)) return ''
+  if (!watchesTickets && !lanes.some(({ pullRequests }) => pullRequests.length > 0)) return ''
   return watch.kind === WATCH_HEALTH.off ? texts.watcherOff : texts.stale(watch.minutes)
 }
 
 const laneColumnsOf = (lanes: LaneView[]): LaneColumns => ({
   name: Math.min(Math.max(0, ...lanes.map(({ progress }) => textWidth(progress.lane.name))), NAME_WIDTH_MAX),
-  marks: Math.max(0, ...lanes.map((lane) => visibleLength(pullRequestMarks(lane)))),
+  marks: Math.max(0, ...lanes.map((lane) => visibleLength(laneMarks(lane)))),
   right: Math.max(0, ...lanes.map((lane) => visibleLength(laneRight(lane)))),
 })
 
@@ -864,7 +958,7 @@ const partitionLanes = (lanes: LaneView[]): Record<'active' | 'waiting' | 'noAge
  * lanes with a worktree but no agent each share a closing block; finished lanes are not drawn.
  */
 export const renderScreen = (
-  { title, time, lanes, planned, watch, language = PLAN_LANGUAGE.en }: OverviewView,
+  { title, time, lanes, planned, watch, watchesTickets, language = PLAN_LANGUAGE.en }: OverviewView,
   state: Selection,
   width: number,
 ): Screen => {
@@ -873,10 +967,10 @@ export const renderScreen = (
   const columns = laneColumnsOf(active)
   const badgeTexts = BADGE_TEXTS[language]
   const blocks = active.map((lane) => laneBlock(lane, state, width, columns, badgeTexts))
-  const notice = watchNotice(active, watch, badgeTexts)
+  const notice = watchNotice({ lanes: active, watch, watchesTickets }, badgeTexts)
   const clock = notice ? `${paint.yellow(notice)}${COLUMN_SEPARATOR}${paint.dim(time)}` : paint.dim(time)
   return {
-    header: [spread(paint.bold(title), clock, width), rule(width)],
+    header: [spread(`${HEADER_MARK} ${paint.bold(title)}`, clock, width), rule(width)],
     body: joinFrames([
       ...separate(blocks, width),
       ...(parked.length > 0 ? [textFrame([rule(width), ...parked])] : []),