jackherd 1.6.1 → 1.7.0

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])] : []),

package/src/plans/live.ts

@@ -3,6 +3,7 @@ import { dirname } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { terminalSafe } from '../plan-format/terminal-text'
 import { openInBrowser } from '../terminal/open'
+import type { LaneMemory } from './current-phase'
 import { errorText } from './error-text'
 import {
   type FetchState,
@@ -50,6 +51,8 @@ type Live = {
   /** This clone's `FETCH_HEAD`, watched beside the plan files; null when git names none. */
   fetchHead: string | null
   reported: Map<string, string | null>
+  /** Per lane, the ticks seen at the last read and the phase that moved last; the herd's start empties it. */
+  memories: Map<string, LaneMemory>
   pending: Timer | null
   /** The snapshot as read, without the plan chips; `snapshot` is this plus the chips of `page`. */
   read: Snapshot | null
@@ -185,7 +188,7 @@ const refresh = (live: Live, onChange: () => void): Promise<void> => {
 
 const readOnce = async (live: Live, onChange: () => void) => {
   try {
-    const read = await loadSnapshot(live.source, live.pullRequests)
+    const read = await loadSnapshot(live.source, live.pullRequests, live.memories)
     const next = withKnownPage(live, read)
     live.read = read
     if (!live.snapshot) live.view = { ...live.view, selection: startSelection(next, live.source.options) }
@@ -277,6 +280,7 @@ export const runLive = (source: Source): void => {
     watchers: new Map(),
     fetchHead: fetchHeadPath(source.root),
     reported: new Map(),
+    memories: new Map(),
     pending: null,
     read: null,
     page: null,

package/src/plans/phase-models-read.ts

@@ -0,0 +1,37 @@
+import { lstatSync, readdirSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { isPhaseModelRecord, type PhaseModelRecord } from './phase-models'
+
+/** The file name the hook gives a record: 16 hex characters of a hash over plan and phase. */
+const RECORD_FILE = /^[0-9a-f]{16}\.json$/
+
+/** A record is a line of JSON; anything larger was not written by the hook. */
+const MAX_RECORD_BYTES = 4 * 1024
+
+/** A plain file of record size: a link could read elsewhere and a pipe would block the herd, so neither is read. */
+const isRecordFile = (path: string): boolean => {
+  const entry = lstatSync(path)
+  return entry.isFile() && entry.size < MAX_RECORD_BYTES
+}
+
+const recordOf = (path: string): PhaseModelRecord[] => {
+  try {
+    if (!isRecordFile(path)) return []
+    const record: unknown = JSON.parse(readFileSync(path, 'utf8'))
+    return isPhaseModelRecord(record) ? [record] : []
+  } catch {
+    return []
+  }
+}
+
+/** Every record of the model log in the main checkout; nothing when the directory is missing or unreadable. */
+export const readPhaseModels = (root: string): PhaseModelRecord[] => {
+  const directory = join(root, '.jackherd', 'models')
+  try {
+    return readdirSync(directory)
+      .filter((name) => RECORD_FILE.test(name))
+      .flatMap((name) => recordOf(join(directory, name)))
+  } catch {
+    return []
+  }
+}

package/src/plans/phase-models.ts

@@ -0,0 +1,70 @@
+import { type LaneProgress, resolvePlanPath } from '../plan-format'
+import { isRecord } from '../watch/json-guards'
+
+/** The model families a phase ran on and was recommended, as lower-case words; `fits` null without a recommendation. */
+export type PhaseModel = { used: string; recommended: string | null; fits: boolean | null }
+
+/**
+ * A record as the kit's model log hook writes it to `.jackherd/models/<key>.json` in the main checkout: the plan from
+ * the repository root, the phase, the model id of the subagent's last answer and when it ended. Same shape as
+ * `PhaseModelRecord` in the hook, which this package does not import at run time.
+ */
+export type PhaseModelRecord = PhaseModel & { plan: string; phase: string; model: string; at: number }
+
+/** A family as a word of at most 16 lower-case letters, so a record cannot widen the phase row. */
+const FAMILY = /^[a-z]{1,16}$/
+
+const isFamily = (value: unknown): value is string => typeof value === 'string' && FAMILY.test(value)
+
+const isVerdict = (recommended: unknown, fits: unknown): boolean =>
+  (recommended === null && fits === null) || (isFamily(recommended) && typeof fits === 'boolean')
+
+export const isPhaseModelRecord = (value: unknown): value is PhaseModelRecord =>
+  isRecord(value) &&
+  typeof value.plan === 'string' &&
+  typeof value.phase === 'string' &&
+  typeof value.model === 'string' &&
+  isFamily(value.used) &&
+  isVerdict(value.recommended, value.fits) &&
+  typeof value.at === 'number'
+
+/** The key of a phase of a lane's step in `LaneView.models`. */
+export const phaseModelKey = (stepIndex: number, phaseId: string): string => `${stepIndex}:${phaseId}`
+
+const recordKey = (plan: string, phase: string): string => `${plan}\n${phase}`
+
+/** The newest record per plan and phase. */
+const newestByPhase = (records: readonly PhaseModelRecord[]): Map<string, PhaseModelRecord> => {
+  const newest = new Map<string, PhaseModelRecord>()
+  for (const record of records) {
+    const key = recordKey(record.plan, record.phase)
+    const known = newest.get(key)
+    if (!known || record.at > known.at) newest.set(key, record)
+  }
+  return newest
+}
+
+/** The model of every phase of the lane's steps that has a record, by `phaseModelKey`. */
+export const laneModelsOf = (
+  progress: LaneProgress,
+  records: readonly PhaseModelRecord[],
+  sprintDirectory: string,
+): Record<string, PhaseModel> => {
+  const newest = newestByPhase(records)
+  return Object.fromEntries(
+    progress.steps.flatMap(({ step, phases }, stepIndex) => {
+      const plan = step.planHref ? resolvePlanPath(sprintDirectory, step.planHref) : null
+      return phases.flatMap((phase) => {
+        const record = plan === null ? undefined : newest.get(recordKey(plan, phase.id))
+        return record
+          ? [
+              [
+                phaseModelKey(stepIndex, phase.id),
+                { used: record.used, recommended: record.recommended, fits: record.fits },
+              ],
+            ]
+          : []
+      })
+    }),
+  )
+}