jackherd 1.18.2 → 1.19.0

package/src/plans/layout.ts

@@ -1,6 +1,6 @@
 import { TONE, TONE_ROLE } from '../config/tones'
 import { CONTEXT_LEVEL, type ContextLevel, type ContextReading, contextLabel } from '../context'
-import type { LaneProgress, PhaseProgress } from '../plan-format'
+import type { LaneProgress, PhaseProgress, PlanStep } from '../plan-format'
 import { currentPhase, isPhaseOpen, phaseLabel } from '../plan-format'
 import { ellipsize } from '../plan-format/terminal-text'
 import type { WaitingItem } from '../plan-format/waiting'
@@ -36,8 +36,10 @@ import type { UnplannedTask } from './active-tasks'
 import type { SubagentLine } from './activity-read'
 import { type AgentOf, clickHint } from './click-hint'
 import { type CoordinatorView, coordinatorShortName, coordinatorText } from './coordinator-row'
+import { type FoldedDetailParts, foldedDetail } from './folded-detail'
 import { type Frame, indented, joinFrames, narrower, rowFrame, spaced, textFrame, unpainted } from './frame'
 import { groomedText } from './groomed'
+import { laneLead, portBadge } from './lane-line'
 import {
   LANE_REASON,
   type LaneReason,
@@ -60,7 +62,7 @@ import {
   STILL_TASK,
   type TaskStyle,
 } from './layout-phase'
-import { foldedTaskLine, openLaneFrame } from './layout-summary'
+import { foldedTaskLine, openLaneFrame, reportedTexts } from './layout-summary'
 import { legendLines } from './legend'
 import { chipKey, type LinkChip, planUrlOf } from './link-chips'
 import { plain } from './markdown-text'
@@ -112,6 +114,7 @@ import {
   statusOnly,
 } from './source-rows'
 import { chevronOf, LESS_MARK, NO_AGENT_SYMBOL, statusSymbol, statusWord, TURN_MARK } from './symbols'
+import { shortTitle } from './task-name'
 import { BADGE_TEXTS, type BadgeTexts, checksText, foldedChecksText, laneMarkText, TEXTS } from './texts'
 import { paintOfRole, paintOfTone, toneOfRole } from './tones'
 import {
@@ -158,6 +161,10 @@ export type LaneView = {
   restNote?: string | null
   /** The last action of the lane's agent and of its running subagents, from their logs; absent without a source. */
   activity?: LaneActivity
+  /** True while a server listens on the lane's port (`isPortListening`); absent or false shows no port badge. */
+  listening?: boolean
+  /** The ids of every `### Phase` heading of each plan the lane names, by plan link in plan order: the `y` of `P2/5`. */
+  planPhaseIds?: Record<string, string[]>
 }
 
 /** `lane` is null while the agent's log holds no action; the lines show only while the lane works. */
@@ -204,6 +211,8 @@ export type Screen = {
   focusHits: FocusHit[]
   /** The keys of the rows the arrows walk, in screen order: the rows of the blocks on top, then those of the body. */
   rowKeys: string[]
+  /** The keys of the folded lanes whose step row shows only with the focus: the screen without one lacks that row. */
+  stepRowKeys: string[]
 }
 
 /**
@@ -669,12 +678,6 @@ const headPhase = (view: LaneView): PhaseProgress | null => {
   return signalled ?? latest ?? (current && isPhaseOpen(current) ? current : null)
 }
 
-/** `P9 Release 1.0` for the phase the lane line names; empty when there is none. */
-const nextPhaseLabel = (view: LaneView): string => {
-  const phase = headPhase(view)
-  return phase ? `${phaseLabel(phase.id)}${phase.title ? ` ${plain(phase.title)}` : ''}` : ''
-}
-
 const markTone = ({ feedback, changesRequested }: PullRequestBadges): BadgeTone => {
   if (changesRequested) return BADGE_TONE.red
   return feedback > 0 ? BADGE_TONE.amber : BADGE_TONE.grey
@@ -706,21 +709,28 @@ const ticketMark = (tickets: LaneTickets | undefined): string[] => {
   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(' ')
+/** The lane's port badge while its server listens; empty without a port or a listener. Only an open lane draws it. */
+const lanePortBadge = ({ progress, listening }: LaneView): string => portBadge(progress.lane.port, listening === true)
 
 /**
- * `P3 Search API +1 · 12/20` for a folded lane: the phase it names, `+n` for the other active phases, the phase's
- * ticked boxes. An open lane names it on a phase branch, so its own line does not.
+ * The click target over the cells of the lane's port badge on `line`, a line of its own frame, so a click on the badge
+ * opens the server and does not fold the lane; none while the badge is not on the line.
  */
-const foldedPhaseLabel = (view: LaneView): string => {
-  const phase = headPhase(view)
-  if (!phase) return ''
-  const more = summaryOf(view).active.filter((active) => active.phase.id !== phase.id).length
-  return `${nextPhaseLabel(view)}${more > 0 ? ` +${more}` : ''} · ${phase.done}/${phase.total}`
+const portTargets = (view: LaneView, line: string): ClickTarget[] => {
+  const { port } = view.progress.lane
+  const badgeText = lanePortBadge(view)
+  const start = badgeText ? line.indexOf(badgeText) : -1
+  if (port === null || start < 0) return []
+  const from = visibleLength(line.slice(0, start))
+  return [{ line: 0, from, to: from + visibleLength(badgeText), key: chipKey(`http://localhost:${port}`) }]
 }
 
+/** 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)]
+    .filter(Boolean)
+    .join(' ')
+
 /** A lane whose agent rests (idle or done): the folded line says what it waits on, and its phase without the bar. */
 const restsFolded = ({ status }: LaneView, open: boolean): boolean => !open && isRestingAgent(status.agent)
 
@@ -735,25 +745,98 @@ const reasonText = (reason: LaneReason | null): string => {
   return `${label} ${reason.text}`
 }
 
-/** `P4 12/18`: the phase a resting lane names and its ticked boxes, without the title the reason takes the room of. */
-const restingPhaseLabel = (view: LaneView): string => {
+/** The plan step the lane line names: the one of its running phase, else its current one, else its first with a plan. */
+const headStep = (view: LaneView): PlanStep | undefined => {
+  const { lane, current } = view.progress
+  const stepIndex = headActive(view)?.stepIndex ?? current?.stepIndex
+  const step = stepIndex === undefined ? undefined : lane.steps[stepIndex]
+  return step?.planHref ? step : lane.steps.find(({ planHref }) => planHref)
+}
+
+/** `P2/5` for the phase's place among the plan's phase headings; the phase's label alone while the plan's list is unknown. */
+const phaseCountLabel = (view: LaneView, phase: PhaseProgress, href: string): string => {
+  const ids = view.planPhaseIds?.[href] ?? []
+  const place = ids.indexOf(phase.id)
+  return place < 0 ? phaseLabel(phase.id) : `${phaseLabel(String(place + 1))}/${ids.length}`
+}
+
+/**
+ * The plan and the phase a folded lane line names: the plan's short title, `P2/5` from the plan's phase headings (not
+ * from its boxes), the phase name with `+n` for the other running phases. Null while the lane names no phase or its
+ * plan cannot be told, which the line then answers with the branch.
+ */
+const planParts = (
+  view: LaneView,
+): Pick<FoldedDetailParts, 'plan' | 'phaseCount' | 'phaseName' | 'phaseMore'> | null => {
   const phase = headPhase(view)
-  return phase ? paint.dim(`${phaseLabel(phase.id)} ${phase.done}/${phase.total}`) : ''
+  const step = headStep(view)
+  if (!phase || !step?.planHref) return null
+  const more = summaryOf(view).active.filter((active) => active.phase.id !== phase.id).length
+  const name = phase.title ? plain(phase.title) : ''
+  return {
+    plan: plain(shortTitle(step.planTitle)).trim(),
+    phaseCount: phaseCountLabel(view, phase, step.planHref),
+    phaseName: name,
+    phaseMore: more > 0 ? TEXTS.morePhases(more) : '',
+  }
+}
+
+/** Whether the folded lane line knows the plan of its lane; a lane that does not shows its reported step all along. */
+const namesPlan = (view: LaneView): boolean => planParts(view) !== null
+
+/** `⎇ branch` dim in place of plan and phase for a lane whose plan is not known; empty without a worktree. */
+const branchPart = ({ status }: LaneView): string => (status.branch ? paint.dim(`${BRANCH_MARK} ${status.branch}`) : '')
+
+/** The step a running lane is on: the first task it reports; empty while it reports none. */
+const stepOf = (view: LaneView): string => reportedTexts(headActive(view), summaryOf(view), TEXTS.herd)[0] ?? ''
+
+/** The status a folded lane line opens with and the words behind it (`laneLead`); empty for a lane without a state. */
+const foldedStatus = (view: LaneView, reason: LaneReason | null, maxText: number): string =>
+  laneLead({
+    agent: view.status.agent,
+    reason,
+    minutesAgo: headActive(view)?.minutesAgo ?? null,
+    step: stepOf(view),
+    maxText,
+  })
+
+/** The cells around the status text: the `·` before it and the one between status and phase count. */
+const STATUS_GAPS = 6
+
+/** The status of a folded lane line with its text cut to what `room` leaves once the phase count stands whole. */
+const statusWithin = (view: LaneView, reason: LaneReason | null, room: number, countWidth: number): string => {
+  const bare = visibleLength(foldedStatus(view, reason, 0))
+  return foldedStatus(view, reason, room - bare - STATUS_GAPS - countWidth)
 }
 
 /**
- * What follows the status on a lane line: the marker, the reason a resting lane rests, and, folded only, the phase it
- * works on (a resting one by its label and count); the branch is on the session line. Wider than `room`, the reason
- * is cut and the phase stays whole behind it.
+ * What follows the status on a lane line: the marker and the reason a resting lane rests; folded, the plan, the phase
+ * `P2/5 Name` and the reason after them (a resting lane's plan and phase dim), the branch in place of plan and phase
+ * when the plan is unknown. Wider than `room`, the plan title gives way first and the reason last (`foldedDetail`).
  */
 const laneDetail = (view: LaneView, open: boolean, reason: LaneReason | null, room: number): string => {
   const markText = laneMarkText(view)
   const marker = markText ? paint.yellow(markText) : ''
-  const phase = restsFolded(view, open) ? restingPhaseLabel(view) : open ? '' : foldedPhaseLabel(view)
-  const lead = [agentLabel(view.status.agent), marker, reasonText(reason)].filter(Boolean).join(' ')
-  if (!reason || !phase) return [lead, phase].filter(Boolean).join(' ')
-  const leadRoom = Math.max(room - COLUMN_SEPARATOR.length - visibleLength(phase), 1)
-  return `${visibleLength(lead) > leadRoom ? fit(lead, leadRoom) : lead}${COLUMN_SEPARATOR}${phase}`
+  const lead = [agentLabel(view.status.agent), marker].filter(Boolean).join(' ')
+  if (open) return [lead, reasonText(reason)].filter(Boolean).join(' ')
+  const resting = restsFolded(view, open)
+  const dimmed = (text: string) => (resting && text ? paint.dim(text) : text)
+  const parts = planParts(view)
+  const status = statusWithin(view, reason, room, visibleLength(parts?.phaseCount ?? ''))
+  const where = parts
+    ? {
+        ...parts,
+        plan: parts.plan && paint.dim(parts.plan),
+        phaseCount: dimmed(parts.phaseCount),
+        phaseName: dimmed(parts.phaseName),
+        phaseMore: dimmed(parts.phaseMore),
+      }
+    : { plan: branchPart(view), phaseCount: '', phaseName: '', phaseMore: '' }
+  if (status) {
+    const behind = where.plan || where.phaseCount ? paint.dim(' ·') : ''
+    return foldedDetail({ ...where, lead: `${[marker, status].filter(Boolean).join(' ')}${behind}`, reason: '' }, room)
+  }
+  return foldedDetail({ lead, ...where, reason: reasonText(reason) }, room)
 }
 
 /**
@@ -837,8 +920,39 @@ const markedRight = (view: LaneView, columns: LaneColumns): string =>
 const markedRightTight = (view: LaneView, columns: LaneColumns): string =>
   marksBeforeRight(view, columns, (right) => (right ? Math.max(columns.right - visibleLength(right), 0) : 0))
 
-/** The task row below a folded lane's phase row, under the lane's name; none while the lane reports no task. */
-const foldedTaskRow = (view: LaneView, indent: string, width: number, style: TaskStyle): string[] => {
+/** `markedRight` without any padding: the last resort of a lane whose detail needs the room the alignment would take. */
+const markedRightBare = (view: LaneView, columns: LaneColumns): string => marksBeforeRight(view, columns, () => 0)
+
+/**
+ * When no right column leaves room for the whole detail: the bare one while the detail still stands beside it, so
+ * the plan gives way and not the question and the phase count, else the tight one, which sends it to a line of its own.
+ */
+const roomierFallback = (head: string, aligned: string, roomier: string[], width: number, indent: string): string => {
+  const bare = roomier.at(-1) ?? aligned
+  return detailFitsBeside(head, bare, width, indent) ? bare : (roomier[1] ?? aligned)
+}
+
+/** Whether the row of the lane has the focus, by the arrows or the mouse. */
+const hasFocus = ({ selected, hovered }: Selection, lane: string): boolean =>
+  selected === laneKey(lane) || hovered === laneKey(lane)
+
+/**
+ * The task row below a folded lane's line, under the lane's name: only while the lane has the focus (the mouse on it),
+ * or always for a lane whose plan is not known; none while the lane reports no task.
+ */
+const foldedTaskRow = (
+  view: LaneView,
+  indent: string,
+  { width, style, state }: { width: number; style: TaskStyle; state: Selection },
+): string[] =>
+  namesPlan(view) && !hasFocus(state, view.progress.lane.name) ? [] : taskLineOf(view, indent, { width, style })
+
+/** The task line of a folded lane, whether or not it is shown now; none while the lane reports no task. */
+const taskLineOf = (
+  view: LaneView,
+  indent: string,
+  { width, style }: { width: number; style: TaskStyle },
+): string[] => {
   const phase = headPhase(view)
   const summary = summaryOf(view)
   const active = summary.active.find((each) => each.phase.id === phase?.id)
@@ -853,7 +967,7 @@ const foldedTaskRow = (view: LaneView, indent: string, width: number, style: Tas
 const laneLines = (
   view: LaneView,
   open: boolean,
-  { width, taskStyle }: Pick<LanesContext, 'width' | 'taskStyle'>,
+  { width, taskStyle, state }: Pick<LanesContext, 'width' | 'taskStyle' | 'state'>,
   columns: LaneColumns,
   reason: LaneReason | null,
 ): string[] => {
@@ -863,10 +977,14 @@ const laneLines = (
   const head = `${paint.dim(chevronOf(open))} ${symbolCell(status.agent)} ${cells}`
   const nameIndent = ' '.repeat(visibleLength(head) - visibleLength(cells))
   const aligned = open ? laneProgressColumn(view, tallyWidthOf(columns)) : markedRight(view, columns)
-  const right = open || detailFitsBeside(head, aligned, width, nameIndent) ? aligned : markedRightTight(view, columns)
+  const wanted = open ? 0 : visibleLength(laneDetail(view, open, reason, width * 2))
+  const fitsWhole = (right: string) =>
+    detailFitsBeside(head, right, width, nameIndent) && detailPlacement(head, right, width, nameIndent).room >= wanted
+  const roomier = [aligned, markedRightTight(view, columns), markedRightBare(view, columns)]
+  const right = open ? aligned : (roomier.find(fitsWhole) ?? roomierFallback(head, aligned, roomier, width, nameIndent))
   const { room } = detailPlacement(head, right, width, nameIndent)
   const lines = withDetail(head, laneDetail(view, open, reason, room), right, width, nameIndent)
-  return open ? lines : [...lines, ...foldedTaskRow(view, nameIndent, width, taskStyle)]
+  return open ? lines : [...lines, ...foldedTaskRow(view, nameIndent, { width, style: taskStyle, state })]
 }
 
 /** The running phase the lane line names, with its step and age; undefined while it names none or that one does not run. */
@@ -898,8 +1016,15 @@ const idleLabel = (view: LaneView): string => {
 const sessionLine = (view: LaneView, width: number): string => {
   const words = [modelLabel(view), idleLabel(view)].filter(Boolean).map((word) => paint.dim(word))
   const left = [gitLabel(view.status), ...words].join(paint.dim(PLACE_SEPARATOR))
-  const context = contextValue(view.context)
-  return spread(fit(left, Math.max(width - (context ? CONTEXT_CELL_WIDTH : 0), 1)), context, width)
+  const right = [lanePortBadge(view), contextValue(view.context)].filter(Boolean).join(' ')
+  const reserved = right ? Math.max(visibleLength(right) + 1, CONTEXT_CELL_WIDTH) : 0
+  return spread(fit(left, Math.max(width - reserved, 1)), right, width)
+}
+
+/** The session line of an open lane, with a click target over its port badge. */
+const sessionFrame = (view: LaneView, width: number): Frame => {
+  const line = sessionLine(view, width)
+  return { ...textFrame([line]), targets: portTargets(view, line) }
 }
 
 /** How many of `cells` fit on one line of `width` cells with the `+<n>` for the rest; at least one, which is then cut. */
@@ -1013,11 +1138,11 @@ const showsLaneActivity = ({ activity, status }: LaneView): boolean =>
 /** True when a task line of the lane shimmers: the pane shimmers its tasks and the lane reports one to show. */
 const showsShimmeringTask = (
   view: LaneView,
-  { width, taskStyle }: Pick<LanesContext, 'width' | 'taskStyle'>,
-): boolean => taskStyle === SHIMMERING_TASK && foldedTaskRow(view, '', width, taskStyle).length > 0
+  { width, taskStyle, state }: Pick<LanesContext, 'width' | 'taskStyle' | 'state'>,
+): boolean => taskStyle === SHIMMERING_TASK && foldedTaskRow(view, '', { width, style: taskStyle, state }).length > 0
 
 /** True when no line of the lane shimmers yet, so its first subagent line does: neither its activity nor its task. */
-const subagentLeads = (view: LaneView, context: Pick<LanesContext, 'width' | 'taskStyle'>): boolean =>
+const subagentLeads = (view: LaneView, context: Pick<LanesContext, 'width' | 'taskStyle' | 'state'>): boolean =>
   !showsLaneActivity(view) && !showsShimmeringTask(view, context)
 
 /**
@@ -1043,14 +1168,14 @@ const laneBlock = (
     taskStyle,
   }
   const open = isLaneOpen(state, view.progress.lane.name, view.status.agent)
-  const lines = laneLines(view, open, { width, taskStyle }, columns, reason)
+  const lines = laneLines(view, open, { width, taskStyle, state }, columns, reason)
   const lane = rowFrame(laneKey(view.progress.lane.name), lines, [], context)
-  const leadsSubagent = subagentLeads(view, { width, taskStyle: lanesTaskStyle })
+  const leadsSubagent = subagentLeads(view, { width, taskStyle: lanesTaskStyle, state })
   const row = joinFrames([lane, ...activityFrames(view, { state, width, activityStyle, leadsSubagent })])
   if (!open) return row
   const inner = narrower(context, LANE_HEAD_CELLS)
   const head = {
-    session: textFrame([sessionLine(view, inner.width)]),
+    session: sessionFrame(view, inner.width),
     chips: chipLine(chipCells(laneChips(view), inner.tickets, view.sentFiles), inner.width),
     pullRequests: pullRequestsFrame(view, inner),
   }
@@ -1479,17 +1604,25 @@ const reasonInputOf = ({ progress, status, restNote }: LaneView): ReasonInput =>
   restNote,
 })
 
-/** `1 waits on you · 3 idle`: what waits on you in the tone of what waits, the idle count dim; a part at 0 left out. */
+/** `1 needs you · 3 idle`: what needs you in the tone of what waits, the idle count dim; a part at 0 left out. */
 const lanesBalanceText = (lanes: readonly LaneView[]): string => {
   const { waitsOnYou, idle } = lanesBalance(lanes.map(reasonInputOf))
   return [
-    waitsOnYou > 0 ? paintOfRole(TONE_ROLE.waiting)(TEXTS.lanesWaitOnYou(waitsOnYou)) : '',
+    waitsOnYou > 0 ? paintOfRole(TONE_ROLE.waiting)(TEXTS.lanesNeedYou(waitsOnYou)) : '',
     idle > 0 ? paint.dim(TEXTS.lanesIdle(idle)) : '',
   ]
     .filter(Boolean)
     .join(paint.dim(` ${ITEM_SEPARATOR} `))
 }
 
+/** The keys of the folded lanes that lay a step row below their line once they have the focus. */
+const stepRowKeysOf = (lanes: readonly LaneView[], { state, width, taskStyle }: LanesContext): string[] =>
+  lanes.flatMap((view) => {
+    const { name } = view.progress.lane
+    const hidden = !isLaneOpen(state, name, view.status.agent) && namesPlan(view)
+    return hidden && taskLineOf(view, '', { width, style: taskStyle }).length > 0 ? [laneKey(name)] : []
+  })
+
 /**
  * The lanes at work under the head `▾ Lanes · <n>  <balance>`, open at the start; each lane indented under it, a
  * blank line after an open lane, none above it, so its row keeps its screen line when it opens and folds under the
@@ -1617,6 +1750,7 @@ export const renderScreen = (
     sourceBlock: stack.hits[sourcesSlot],
     focusHits: state.showLegend ? focusHits.filter(({ line }) => line < plainHeader.length) : focusHits,
     rowKeys: [...blockHits.map(({ key }) => key), ...targetKeys(body.targets)],
+    stepRowKeys: stepRowKeysOf(active, { state, width, badgeTexts, taskStyle, activityStyle }),
     header,
     body: state.showLegend ? textFrame(legendLines(TEXTS.legend, width)) : body,
     footer: [

package/src/plans/port-listening.ts

@@ -0,0 +1,25 @@
+import { createConnection } from 'node:net'
+
+/** How long a connection to the lane's port may take before the port counts as closed. */
+const CONNECT_TIMEOUT_MS = 150
+
+/** Whether something accepts a connection on `port` of this machine; a refusal, an error or the timeout answer false. */
+export const isPortListening = (port: number, timeoutMs = CONNECT_TIMEOUT_MS): Promise<boolean> =>
+  new Promise((resolve) => {
+    const socket = createConnection({ port, host: '127.0.0.1' })
+    const settle = (listening: boolean) => {
+      socket.destroy()
+      resolve(listening)
+    }
+    socket.setTimeout(timeoutMs)
+    socket.once('connect', () => settle(true))
+    socket.once('timeout', () => settle(false))
+    socket.once('error', () => settle(false))
+  })
+
+/** The ports of `ports` something listens on, probed side by side; a lane without a port (null) is skipped. */
+export const listeningPorts = async (ports: readonly (number | null)[]): Promise<Set<number>> => {
+  const unique = [...new Set(ports.filter((port): port is number => port !== null))]
+  const answers = await Promise.all(unique.map(async (port) => ((await isPortListening(port)) ? port : null)))
+  return new Set(answers.filter((port): port is number => port !== null))
+}

package/src/plans/selection.ts

@@ -166,6 +166,17 @@ const ITEM_KEY = new RegExp(`^(${PHASE_KEY_SHAPE})#(\\d+)$`)
  */
 export const itemKey = (phase: string, index: number): string => `${phase}#${index}`
 
+const MORE_TASKS_SUFFIX = '>more'
+
+/** The key of the second count row of a phase's checklist, which lists all its tasks like the first one (the phase key). */
+export const moreTasksKey = (phase: string): string => `${phase}${MORE_TASKS_SUFFIX}`
+
+/** The phase key a second count row's key belongs to, null for any other key. */
+export const phaseOfMoreTasksKey = (key: string): string | null =>
+  key.endsWith(MORE_TASKS_SUFFIX) && isPhaseKey(key.slice(0, -MORE_TASKS_SUFFIX.length))
+    ? key.slice(0, -MORE_TASKS_SUFFIX.length)
+    : null
+
 const TASK_REST_PREFIX = 'rest>'
 
 /** The key of the `▸ n more lines` row under an opened task, which opens the rest of its text. */

package/src/plans/snapshot.ts

@@ -62,6 +62,7 @@ import { readPhaseModels } from './phase-models-read'
 import { parsedPlanPhases } from './plan-cache'
 import { laneHeads, PULL_HEAD_NAMESPACE, planPullRequests, readerOncePerRef } from './plan-heads'
 import { markStale, type PlannedPlan, plannedPlans } from './planned'
+import { listeningPorts } from './port-listening'
 import type { PullRequest } from './pull-requests'
 import type { ReadCache } from './read-cache'
 import { type SentChip, sentChipsByLane } from './sent-files'
@@ -95,6 +96,8 @@ export type Source = {
   readSubagents?: (root: string, worktreeDirectory: string) => Map<string, LaneSubagents>
   /** What agents report doing (Claude's task lists, `jh task`); defaults to reading `~/.claude/projects` and `.jackherd/tasks/`. */
   readSignals?: (root: string, worktreeDirectory: string, now: number) => TaskSignal[]
+  /** Which of the lanes' ports a server listens on, probed once per snapshot; defaults to connecting to localhost. */
+  probePorts?: (ports: readonly (number | null)[]) => Promise<ReadonlySet<number>>
 }
 
 /**
@@ -194,6 +197,8 @@ type LaneSet = { lanes: SprintLane[]; unlisted: UnlistedLane[]; sources: LaneSou
 
 /** What a lane's view is decorated with after it was read. */
 type Decorations = {
+  /** The ports a server listens on; a lane whose port is among them shows its port badge. */
+  listening: ReadonlySet<number>
   reading: SourcedWatchReading | null
   phaseModels: readonly PhaseModelRecord[]
   sprintDirectory: string
@@ -347,6 +352,9 @@ const laneView = async (
   const laneSubagents = sources.subagents.get(lane.name)
   const view: LaneView = {
     progress,
+    planPhaseIds: Object.fromEntries(
+      Object.entries(phasesByHref).map(([href, phases]) => [href, phases.map(({ id }) => id)]),
+    ),
     ...running,
     chips: Object.fromEntries(
       Object.entries(texts).map(([href, text]) => [href, extractLinkChips(text, settings.linkKinds)]),
@@ -488,6 +496,11 @@ const withSentFiles = (view: LaneView, chips: ReadonlyMap<string | null, SentChi
 }
 
 /** The view with what its resting lane waits on, read from the lane's report as the watcher reads it; as it was while the agent works. */
+const withListening = (view: LaneView, listening: ReadonlySet<number>): LaneView => {
+  const { port } = view.progress.lane
+  return port !== null && listening.has(port) ? { ...view, listening: true } : view
+}
+
 const withRestNote = (view: LaneView, restNoteOf: Decorations['restNoteOf']): LaneView => {
   const note = isRestingAgent(view.status.agent) ? restNoteOf(view.progress.lane.name) : null
   return note === null ? view : { ...view, restNote: note }
@@ -619,19 +632,22 @@ const laneResultsOf = async (
 /** Each lane's view with its tickets, the watcher's badges, its phases' models and the files sent from it. */
 const decoratedViews = (
   results: readonly LaneResult[],
-  { reading, phaseModels, sprintDirectory, sentChips, restNoteOf }: Decorations,
+  { listening, reading, phaseModels, sprintDirectory, sentChips, restNoteOf }: Decorations,
 ): LaneView[] =>
   results.map((result) =>
-    withRestNote(
-      withSentFiles(
-        withModels(
-          withBadges(withTickets(result, reading?.tickets ?? []), reading?.badges ?? {}),
-          phaseModels,
-          sprintDirectory,
+    withListening(
+      withRestNote(
+        withSentFiles(
+          withModels(
+            withBadges(withTickets(result, reading?.tickets ?? []), reading?.badges ?? {}),
+            phaseModels,
+            sprintDirectory,
+          ),
+          sentChips,
         ),
-        sentChips,
+        restNoteOf,
       ),
-      restNoteOf,
+      listening,
     ),
   )
 
@@ -749,7 +765,9 @@ export const loadSnapshot = async (
   const unknownLaneTitle =
     options.lane && results.length === 0 ? boardTexts(settings.board.term).laneNotListed(options.lane) : null
   await gate.pass()
+  const listening = await (source.probePorts ?? listeningPorts)(results.map(({ view }) => view.progress.lane.port))
   const views = decoratedViews(results, {
+    listening,
     reading,
     phaseModels: readPhaseModels(root),
     sprintDirectory,

package/src/plans/task-checklist.ts

@@ -0,0 +1,57 @@
+/** Tasks shown before the running one, and after it, in a window over a long list. */
+export const CHECKLIST_BEFORE = 2
+export const CHECKLIST_AFTER = 4
+
+/** The least a task needs to be placed on the checklist. */
+type Box = { done: boolean }
+
+/**
+ * One row of a phase's checklist: a task by its index in the plan, or a count standing for the tasks the window
+ * leaves out above or below it.
+ */
+export type ChecklistRow = { kind: 'task'; index: number } | { kind: 'above' | 'below'; count: number }
+
+const indexesOf = (start: number, end: number): number[] =>
+  Array.from({ length: Math.max(end - start, 0) }, (_, offset) => start + offset)
+
+const taskRows = (indexes: readonly number[]): ChecklistRow[] => indexes.map((index) => ({ kind: 'task', index }))
+
+/** The task the window is built around: the first one running, else the first open one, else the last one. */
+const anchorOf = (items: readonly Box[], running: readonly number[]): number => {
+  if (running.length > 0) return Math.min(...running)
+  const firstOpen = items.findIndex(({ done }) => !done)
+  return firstOpen === -1 ? items.length - 1 : firstOpen
+}
+
+/**
+ * The index of a phase's running task: the first one in `reported` that is still open, else, while the lane runs the
+ * phase (`laneRuns`), its first open task; null when nothing runs. The tasks agents report (a `jh task start` text a
+ * task names, a task list) win over the plan's order, since the agent knows where it is.
+ */
+export const runningTaskIndexes = (items: readonly Box[], reported: readonly number[], laneRuns: boolean): number[] => {
+  const open = reported.filter((index) => items[index]?.done === false)
+  if (open.length > 0) return [...new Set(open)]
+  const firstOpen = items.findIndex(({ done }) => !done)
+  return laneRuns && firstOpen !== -1 ? [firstOpen] : []
+}
+
+/**
+ * The rows of a phase's checklist, always in the plan's order: ticked tasks first, the running ones, the ones to come.
+ * A short list, or one `expanded` by a click, shows every task. A long one shows a window of `CHECKLIST_BEFORE` tasks
+ * before the first running one and `CHECKLIST_AFTER` after it, widened to hold every running task, with a count row
+ * above and below for what it leaves out, so the order is never broken.
+ */
+export const checklistRows = (items: readonly Box[], running: readonly number[], expanded: boolean): ChecklistRow[] => {
+  const all = indexesOf(0, items.length)
+  if (expanded || items.length <= CHECKLIST_BEFORE + 1 + CHECKLIST_AFTER) return taskRows(all)
+  const anchor = anchorOf(items, running)
+  const start = Math.max(anchor - CHECKLIST_BEFORE, 0)
+  const end = Math.min(Math.max(anchor + CHECKLIST_AFTER, ...running), items.length - 1) + 1
+  const aboveCount = start
+  const belowCount = items.length - end
+  return [
+    ...(aboveCount > 0 ? [{ kind: 'above' as const, count: aboveCount }] : []),
+    ...taskRows(indexesOf(start, end)),
+    ...(belowCount > 0 ? [{ kind: 'below' as const, count: belowCount }] : []),
+  ]
+}