jackherd 1.11.2 → 1.12.0

package/src/plans/groomed.ts

@@ -1,14 +1,14 @@
-import { DAY_MS } from '../plan-format/clock'
 import { APPOINTMENT_VOCABULARY, type PlanLanguage } from '../vocabulary'
 import { readAppointmentTable } from '../watch/appointments'
+import { addCalendarDays, calendarDaysBetween } from './calendar-days'
 
 const GROOMING_INTERVAL_DAYS = 7
 const STALE_FROM_DAYS = 8
 
 /**
- * Whole days since the board was last groomed, or null when the board has no open grooming appointment. The
- * coordinator moves that appointment a week on after each grooming, so the last one was a week before it. A time
- * before that (a board never groomed on the clock) counts as 0.
+ * Calendar days since the board was last groomed, in the clock's time zone, or null when the board has no open
+ * grooming appointment. The coordinator moves that appointment a week on after each grooming, so the last one was a
+ * week before it. A time before that (a board never groomed on the clock) counts as 0.
  */
 export const groomedDaysAgo = (board: string, language: PlanLanguage, now: Date): number | null => {
   const word = APPOINTMENT_VOCABULARY[language].grooming
@@ -16,12 +16,18 @@ export const groomedDaysAgo = (board: string, language: PlanLanguage, now: Date)
     .appointments.filter(({ open, action }) => open && action.toLowerCase().startsWith(word))
     .sort((left, right) => left.when.getTime() - right.when.getTime())[0]
   if (!next) return null
-  const groomedAt = next.when.getTime() - GROOMING_INTERVAL_DAYS * DAY_MS
-  return Math.max(Math.floor((now.getTime() - groomedAt) / DAY_MS), 0)
+  const groomedAt = addCalendarDays(next.when, -GROOMING_INTERVAL_DAYS)
+  return Math.max(calendarDaysBetween(groomedAt, now), 0)
+}
+
+const daysText = (days: number): string => {
+  if (days === 0) return 'today'
+  if (days === 1) return 'yesterday'
+  return `${days}d ago`
 }
 
 /** The header text; `stale` from eight days on, when the herd paints it amber. */
 export const groomedText = (days: number): { text: string; stale: boolean } => ({
-  text: days === 0 ? 'groomed today' : `groomed ${days}d ago`,
+  text: `groomed ${daysText(days)}`,
   stale: days >= STALE_FROM_DAYS,
 })

package/src/plans/lane-reason.ts

@@ -0,0 +1,61 @@
+import type { SprintLane } from '../plan-format'
+import { AGENT_STATUS, isRestingAgent } from '../terminal/types'
+import { REST_QUESTION_COUNT } from '../watch/lane-rest'
+import { waitingNote } from './lane-standing'
+import { plain } from './layout-phase'
+import { shortTitle } from './task-name'
+import { TEXTS } from './texts'
+
+/** What a resting lane waits on: a question to you, a row of "Your turn", its starts-after cell, or nothing known. */
+export const LANE_REASON = { you: 'you', on: 'on', after: 'after', none: 'none' } as const
+export type LaneReasonKind = (typeof LANE_REASON)[keyof typeof LANE_REASON]
+
+/** The reason as the lane line shows it: the label dim, the short text bright. */
+export type LaneReason = { kind: LaneReasonKind; label: string; text: string }
+
+/** A lane as its reason needs it: the board's lane, the status of its agent and the open question of its report. */
+export type ReasonInput = { lane: SprintLane; agent: string | null; restNote?: string | null }
+
+/** A row of "Your turn" as the reason needs it: its text and the lanes it frees. */
+export type UnblockingRow = { text: string; unblocks: readonly string[] }
+
+/** The head of the lanes block counts what waits on you and what idles otherwise. */
+export type LanesBalance = { waitsOnYou: number; idle: number }
+
+/** Cut before the markdown goes: a colon inside backticks does not end the short title. */
+const shortOf = (text: string): string => plain(shortTitle(text)).trim()
+
+/** How many open questions the watcher counted in the report; a note without its count is one. */
+const noteQuestionCount = (note: string): number => Number(note.match(REST_QUESTION_COUNT)?.[1] ?? 1)
+
+/**
+ * Why a resting lane (idle or done) rests: the open questions of its report wait on you, by their count alone (their
+ * text stands as rows of "Your turn"), else a row of "Your turn" that unblocks it, else its starts-after cell, both cut
+ * to their short title, else nothing known, which is meant to stand out. Null for a lane that works or whose agent is
+ * blocked: the blocked word says it waits on you.
+ */
+export const laneReason = (
+  { lane, agent, restNote }: ReasonInput,
+  rows: readonly UnblockingRow[],
+): LaneReason | null => {
+  if (!isRestingAgent(agent)) return null
+  if (restNote)
+    return {
+      kind: LANE_REASON.you,
+      label: TEXTS.restWaitsOnYou,
+      text: TEXTS.restQuestions(noteQuestionCount(restNote)),
+    }
+  const row = rows.find(({ unblocks }) => unblocks.includes(lane.name))
+  if (row) return { kind: LANE_REASON.on, label: TEXTS.restWaitsOn, text: shortOf(row.text) }
+  const after = waitingNote(lane)
+  if (after !== null) return { kind: LANE_REASON.after, label: TEXTS.restAfter, text: shortOf(after) }
+  return { kind: LANE_REASON.none, label: '', text: TEXTS.restNoReason }
+}
+
+const waitsOnYou = ({ agent, restNote }: ReasonInput): boolean =>
+  agent === AGENT_STATUS.blocked || (isRestingAgent(agent) && Boolean(restNote))
+
+export const lanesBalance = (lanes: readonly ReasonInput[]): LanesBalance => ({
+  waitsOnYou: lanes.filter(waitsOnYou).length,
+  idle: lanes.filter((lane) => isRestingAgent(lane.agent) && !waitsOnYou(lane)).length,
+})

package/src/plans/lane-summary.ts

@@ -103,6 +103,9 @@ export type SummaryInput = {
 /** Minutes without a tick after which a phase no longer runs, unless an agent reports it. */
 export const STALE_ACTIVITY_MINUTES = 20
 
+/** How many open tasks an open lane shows under a phase it works on before `▸ <n> more open`. */
+export const SHOWN_OPEN_TASKS = 4
+
 const isWritten = ({ total }: PhaseProgress): boolean => total > 0
 
 const planHrefs = ({ steps }: LaneProgress): string[] => [
@@ -127,6 +130,19 @@ const namedIds = ({ steps }: LaneProgress, href: string): Set<string> =>
     steps.flatMap(({ step }) => (step.planHref === href ? [...step.phaseIds, ...(step.namedPhaseIds ?? [])] : [])),
   )
 
+/**
+ * Whether a phase is a merged leftover: an older board row named it, the newest row does not, and the base branch
+ * carries its ticks as they stand (not `touched`), so its open boxes were left open on purpose, or carries ticks of
+ * it at all (`merged`), so whatever the worktree ticked since is no run of its own. Never one while the lane has no
+ * row.
+ */
+const mergedLeftoverOf = ({ steps }: LaneProgress): IsLeftover => {
+  const row = [...steps].reverse().find(({ step }) => !step.withoutRow)?.step
+  if (!row) return () => false
+  const rowIds = new Set(row.namedPhaseIds ?? row.phaseIds)
+  return (phase) => (phase.touched !== true || phase.merged === true) && !isNamedBy(phase.id, rowIds)
+}
+
 /**
  * The phases of `href` the lane names, in plan order: another lane's phases of the same plan are not its own, however
  * lately they moved.
@@ -149,6 +165,19 @@ type TimedPhase = { phase: PhaseProgress; minutesAgo: number }
 
 type RunningPhase = { phase: PhaseProgress; minutesAgo: number | null }
 
+/** Whether a phase is a merged leftover (`mergedLeftoverOf`): it never runs and waits behind the others. */
+type IsLeftover = (phase: PhaseProgress) => boolean
+
+/**
+ * A merged leftover whose merge the base branch shows (`merged`): its recent ticks are no run of its own, so neither
+ * its movement nor the latest movement makes it run. A leftover without that evidence still runs once it moves.
+ */
+const isMergedRun = (phase: PhaseProgress, isLeftover: IsLeftover): boolean =>
+  phase.merged === true && isLeftover(phase)
+
+/** What decides which open phases wait and in which order: the ids that run, and the merged leftovers. */
+type WaitingContext = { running: ReadonlySet<string>; isLeftover: IsLeftover }
+
 /**
  * A phase whose tasks outside the review gate are partly ticked: work on it has begun and goes on. One with only its
  * review gate open waits for its review, as in `jh check --parallel`.
@@ -217,7 +246,7 @@ const namesReview = (text: string, review: ReviewType): boolean =>
   new RegExp(`(?<![\\w-])${review}(?![\\w-])`).test(text)
 
 /**
- * The review gate box a running review sits on, which gets its `▶` like a reported task: the open one that names the
+ * The review gate box a running review sits on, which gets its `●` like a reported task: the open one that names the
  * review, else the first open one. A phase whose gate is ticked or that has none shows no arrow.
  */
 const reviewTask = ({ items }: PhaseProgress, review: ReviewType, at: number): ActiveTask[] => {
@@ -287,10 +316,18 @@ const unplacedTasks = (input: SummaryInput, signalled: PhaseProgress | null, pla
     : []),
 ]
 
-/** The open phases with a ticked task (`isStarted`) that are not `listed` yet, aged from their last tick when one is known. */
-const startedPhases = (phases: PhaseProgress[], timed: TimedPhase[], listed: readonly RunningPhase[]): RunningPhase[] =>
+/**
+ * The open phases with a ticked task (`isStarted`) that are not `listed` yet, aged from their last tick when one is
+ * known; a merged leftover (`mergedLeftoverOf`) is none, it waits behind the others.
+ */
+const startedPhases = (
+  phases: PhaseProgress[],
+  timed: TimedPhase[],
+  listed: readonly RunningPhase[],
+  isLeftover: IsLeftover,
+): RunningPhase[] =>
   phases
-    .filter((phase) => isPhaseOpen(phase) && isStarted(phase) && !isListed(listed, phase))
+    .filter((phase) => isPhaseOpen(phase) && isStarted(phase) && !isListed(listed, phase) && !isLeftover(phase))
     .map((phase) => ({ phase, minutesAgo: timed.find((each) => each.phase.id === phase.id)?.minutesAgo ?? null }))
 
 /** The signalled phase when no other source lists it yet, aged from its last tick when one is known. */
@@ -304,7 +341,8 @@ const signalledRunning = (
     : []
 
 /**
- * The phases that run: the timed ones ticked less than `STALE_ACTIVITY_MINUTES` ago, the phases a reported task or a
+ * The phases that run: the timed ones ticked less than `STALE_ACTIVITY_MINUTES` ago, merged runs (`isMergedRun`)
+ * aside, the phases a reported task or a
  * running subagent names, the signalled phase (`signalledPhase`), then every other open phase with a ticked task
  * (`isStarted`), with the age of its last tick when one is known, else none. A phase only written down, without a
  * tick, a report or the lane's branch naming it, waits.
@@ -314,11 +352,14 @@ const runningPhases = (
   phases: PhaseProgress[],
   signals: PhaseSignals & { signalled: PhaseProgress | null },
   now: number,
+  isLeftover: IsLeftover,
 ): RunningPhase[] => {
-  const moved = timed.filter(({ minutesAgo }) => minutesAgo < STALE_ACTIVITY_MINUTES)
+  const moved = timed.filter(
+    ({ phase, minutesAgo }) => minutesAgo < STALE_ACTIVITY_MINUTES && !isMergedRun(phase, isLeftover),
+  )
   const reported = [...moved, ...reportedPhases(phases, signals, moved, now)]
   const listed = [...reported, ...signalledRunning(signals.signalled, timed, reported)]
-  return [...listed, ...startedPhases(phases, timed, listed)]
+  return [...listed, ...startedPhases(phases, timed, listed, isLeftover)]
 }
 
 /**
@@ -370,9 +411,11 @@ const otherPlans = (input: SummaryInput, hrefs: string[]): WaitingPhases[] =>
 const byPhaseNumber = (first: PhaseProgress, second: PhaseProgress): number =>
   first.id.localeCompare(second.id, undefined, { numeric: true })
 
-/** The open phases of the current plan that do not run, by number. */
-const waitingIn = (phases: PhaseProgress[], running: ReadonlySet<string>): PhaseProgress[] =>
-  phases.filter((phase) => isPhaseOpen(phase) && !running.has(phase.id)).sort(byPhaseNumber)
+/** The open phases of the current plan that do not run, by number, the merged leftovers (`mergedLeftoverOf`) last. */
+const waitingIn = (phases: PhaseProgress[], { running, isLeftover }: WaitingContext): PhaseProgress[] => {
+  const waiting = phases.filter((phase) => isPhaseOpen(phase) && !running.has(phase.id)).sort(byPhaseNumber)
+  return [...waiting.filter((phase) => !isLeftover(phase)), ...waiting.filter(isLeftover)]
+}
 
 const otherHrefs = (input: SummaryInput, href: string): string[] =>
   planHrefs(input.progress).filter((each) => each !== href)
@@ -382,9 +425,9 @@ const waitingOf = (
   input: SummaryInput,
   href: string,
   phases: PhaseProgress[],
-  running: ReadonlySet<string>,
+  context: WaitingContext,
 ): WaitingPhases[] => {
-  const waiting = waitingIn(phases, running).map(({ id }) => id)
+  const waiting = waitingIn(phases, context).map(({ id }) => id)
   return [
     ...(waiting.length > 0 ? [{ planTitle: null, phaseIds: waiting }] : []),
     ...otherPlans(input, otherHrefs(input, href)),
@@ -400,9 +443,9 @@ const waitingPlaced = (
   input: SummaryInput,
   href: string,
   phases: PhaseProgress[],
-  running: ReadonlySet<string>,
+  context: WaitingContext,
 ): PlacedPhase[] => [
-  ...waitingIn(phases, running).map(placedIn(input.progress, href)),
+  ...waitingIn(phases, context).map(placedIn(input.progress, href)),
   ...otherHrefs(input, href).flatMap((other) =>
     phasesOf(input, other).filter(isPhaseOpen).map(placedIn(input.progress, other)),
   ),
@@ -415,11 +458,16 @@ const finishedOf = (phases: PhaseProgress[]): FinishedPhase[] =>
 type Resting = Pick<LaneSummary, 'waiting' | 'waitingPhases' | 'finished' | 'finishedPhases' | 'unwritten'>
 
 /** What does not run: the phases that wait or are finished, as ids and as phases to open, and those without a checkbox. */
-const restingOf = (input: SummaryInput, href: string, phases: PhaseProgress[], active: ActivePhase[]): Resting => {
-  const running = new Set(active.map(({ phase }) => phase.id))
+const restingOf = (
+  input: SummaryInput,
+  href: string,
+  phases: PhaseProgress[],
+  { active, isLeftover }: { active: ActivePhase[]; isLeftover: IsLeftover },
+): Resting => {
+  const context = { running: new Set(active.map(({ phase }) => phase.id)), isLeftover }
   return {
-    waiting: waitingOf(input, href, phases, running),
-    waitingPhases: waitingPlaced(input, href, phases, running),
+    waiting: waitingOf(input, href, phases, context),
+    waitingPhases: waitingPlaced(input, href, phases, context),
     finished: finishedOf(phases),
     finishedPhases: phases.filter(isPhaseFinished).map(placedIn(input.progress, href)),
     unwritten: stepPhases(input.progress, href)
@@ -438,13 +486,14 @@ type ActiveSources = {
   signalled: PhaseProgress | null
   /** The runs of the lane's subagents, the reviews that name no phase placed (`placedRuns`). */
   subagents: readonly SubagentPhaseRun[]
+  isLeftover: IsLeftover
 }
 
 /** The running phases of the plan on `href`, each with the tasks reported on it, the review gate or the guessed one. */
 const activePhases = (input: SummaryInput, href: string, sources: ActiveSources, now: number): ActivePhase[] => {
-  const { phases, timed, reported, anyFresh, signalled } = sources
+  const { phases, timed, reported, anyFresh, signalled, isLeftover } = sources
   const named = subagentPhases(phases, sources.subagents)
-  const running = runningPhases(timed, phases, { reported, subagents: named, signalled }, now)
+  const running = runningPhases(timed, phases, { reported, subagents: named, signalled }, now, isLeftover)
   const tasks = withReviewTasks(reported, phases, named)
   const guessable = anyFresh ? [] : running.map(({ phase }) => phase).filter(({ id }) => !tasks.has(id))
   return activeOf(input, href, running, tasks, guessedTasks(input, guessable, now))
@@ -477,19 +526,21 @@ export const laneSummary = (input: SummaryInput, now: number): LaneSummary => {
   }
   const phases = phasesOf(input, href)
   const timed = timedPhases(input, href, phases, now)
+  const isLeftover = mergedLeftoverOf(input.progress)
+  const latest = timed.find(({ phase }) => !isMergedRun(phase, isLeftover))?.phase ?? null
   const fresh = freshSignals(input.reported ?? [], newest(Object.values(input.activity)))
-  const { byPhase, unplanned } = assignSignals(phases, fresh)
+  const { byPhase, unplanned } = assignSignals(phases, fresh, latest?.id ?? null)
   const signalled = signalledPhase(phases, byPhase, input.branch ?? null)
   const subagents = placedRuns(input, signalled)
   const onTasks = subagentTaskPlacements(phases, input.describedSubagents ?? [])
   const reported = withTasks(byPhase, onTasks.byPhase)
-  const sources = { phases, timed, reported, anyFresh: fresh.length > 0, signalled, subagents }
+  const sources = { phases, timed, reported, anyFresh: fresh.length > 0, signalled, subagents, isLeftover }
   const active = activePhases(input, href, sources, now)
   return {
     active,
-    latest: timed[0]?.phase ?? null,
+    latest,
     signalled,
-    ...restingOf(input, href, phases, active),
+    ...restingOf(input, href, phases, { active, isLeftover }),
     tally,
     unplanned,
     subagentTasks: unplacedTasks(input, signalled, onTasks.placed),

package/src/plans/layout-phase.ts

@@ -1,16 +1,18 @@
 import type { ChecklistItem, DeferredItem, LaneProgress, PhaseProgress } from '../plan-format'
 import { onlyDocumentationOpen, phaseLabel } from '../plan-format'
 import { terminalSafe } from '../plan-format/terminal-text'
-import { fit, padVisible, paint, spread, wrap } from '../terminal/text'
+import { fit, padVisible, paint, spread, visibleLength } from '../terminal/text'
 import { textWidth } from '../terminal/width'
 import type { WatchBadges } from '../watch/plan-badges'
 import type { ActiveTask, UnplannedTask } from './active-tasks'
-import { type Frame, rowFrame, textFrame } from './frame'
+import { type Frame, joinFrames, rowFrame, textFrame } from './frame'
 import type { LaneTickets } from './lane-tickets'
 import type { LinkChip } from './link-chips'
 import type { PhaseModel } from './phase-models'
-import { itemKey, type Selection, tickedKey } from './selection'
+import { itemKey, type Selection, taskRestKey } from './selection'
+import { shimmering, stillTeal } from './shimmer'
 import { chevronOf, MODEL_MARK, PHASE_COUNT, PHASE_STATE, type PhaseState, phaseStateOf } from './symbols'
+import { taskBrief } from './task-brief'
 import { taskBodyOf, taskNameOf } from './task-name'
 import { type BadgeTexts, TEXTS } from './texts'
 
@@ -26,14 +28,33 @@ export type LaneContext = {
   tickets: LaneTickets | null
   /** The model each phase ran on, by `phaseModelKey`. */
   models: Record<string, PhaseModel>
+  /** How the text of a task an agent reports is drawn. */
+  taskStyle: TaskStyle
 }
 
-export const ACTIVE_MARK = '▶'
-export const GUESSED_MARK = '▷'
+/** How the text of a task an agent reports is drawn, behind its `●`. */
+export type TaskStyle = (text: string) => string
+
+/** A task of a phase: its checkbox, its index in `phase.items`, and what an agent reports of it, absent for none. */
+export type PhaseTask = { item: ChecklistItem; index: number; active: ActiveTask | undefined }
+
+type TaskLook = { mark: string; style: (line: string) => string; suffix: string }
+
+const ACTIVE_MARK = '●'
+const GUESSED_MARK = '◌'
 export const DEFERRED_MARK = '→'
 export const COLUMN_SEPARATOR = '  '
 export const MIN_TITLE_WIDTH = 8
 
+/** The text as it is: a task the herd only guesses from words. */
+const PLAIN_TASK: TaskStyle = (text) => text
+
+/** The text still in the teal the shimmer rests in (lighter than the brand teal of its `●`), while the herd does not shimmer. */
+export const STILL_TASK: TaskStyle = stillTeal
+
+/** The text marked to shimmer (`shimmerAt` draws it). */
+export const SHIMMERING_TASK: TaskStyle = shimmering
+
 /** 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. */
@@ -41,6 +62,7 @@ const COUNT_MARK_WIDTH = 2
 const BLANK_COUNT = ' '.repeat(2 * COUNT_PLACES + 1)
 const COUNT_CELL_WIDTH = COUNT_MARK_WIDTH + 1 + BLANK_COUNT.length
 const MARKDOWN_MARKS = /\*\*|`/g
+const CODE_SPAN = /`([^`]+)`/g
 
 const PHASE_PAINT: Record<PhaseState, (count: string) => string> = {
   [PHASE_STATE.missing]: paint.dim,
@@ -93,120 +115,145 @@ export const modelMark = (model: PhaseModel | undefined): string =>
     ? paint.yellow(`${familyLabel(model.used)} ${MODEL_MARK.differs} ${familyLabel(model.recommended)}`)
     : ''
 
-/** `text` wrapped beside a one-cell `mark`, each line in `style`; follow-up lines indent under the text. */
-const markedLines = (text: string, look: TaskLook, width: number): string[] => {
-  const lines = wrap(plain(text), Math.max(width - 2, 1))
-  return lines.map(
-    (line, index) =>
-      `${index > 0 ? ' ' : look.mark} ${look.style(line)}${index === lines.length - 1 ? look.suffix : ''}`,
-  )
-}
-
 /**
- * The arrow of a phase or task being worked on: a teal `▶` where an agent reported it, a dim teal `▷` where the herd
- * only guesses it from words. Yellow is the herd's colour for what waits on the user.
+ * The mark of a phase or task being worked on: a teal `●` where an agent reported it, a dim teal `◌` where the herd
+ * only guesses it from words. No triangle: in the herd a triangle means a row that opens. Yellow is the herd's colour
+ * for what waits on the user.
  */
 export const activeArrow = (guessed: boolean): string =>
   guessed ? paint.dim(paint.teal(GUESSED_MARK)) : paint.teal(ACTIVE_MARK)
 
-/** The title of a phase or task being worked on: bold where reported, plain where guessed. */
-export const activeTitle = (text: string, guessed: boolean): string => (guessed ? text : paint.bold(text))
-
 /** The agent's name after a title, dim; nothing while only one agent is active. */
 export const agentSuffix = (agent: string | null): string => (agent ? ` ${paint.dim(terminalSafe(agent))}` : '')
 
 /** The agent's name for the right edge of a row, dim; empty while only one agent is active. */
-export const agentCell = (agent: string | null): string => (agent ? paint.dim(terminalSafe(agent)) : '')
+const agentCell = (agent: string | null): string => (agent ? paint.dim(terminalSafe(agent)) : '')
 
 /** Two cells: a task row hangs under its phase's label, which an arrow would otherwise push right. */
 export const TASK_INDENT = '  '
 
-/** `▶ <label> <text>`, the text bold, the agent dim at the right edge. */
-const labelledLine = (label: string, { text, agent }: UnplannedTask, width: number): string =>
-  spread(`${activeArrow(false)} ${label} ${paint.bold(plain(terminalSafe(text)))}`, agentCell(agent), width)
+/** The thin line before each line of an opened task's text, under the task's mark, and the cells it takes with its gap. */
+const RAIL_PREFIX = `${TASK_INDENT}${paint.dim('│')} `
+const RAIL_CELLS = visibleLength(RAIL_PREFIX)
 
-/** `▶ now: <text>`: what an agent reports that no task of the plan names; the agent dim at the right edge. */
-export const nowLine = (task: UnplannedTask, width: number): string => labelledLine(TEXTS.now, task, width)
+/** `● <label> <text>`, the text plain like every task and drawn in `style`, the agent dim at the right edge. */
+const labelledLine = (label: string, { text, agent }: UnplannedTask, width: number, style: TaskStyle): string =>
+  spread(`${activeArrow(false)} ${label} ${style(plain(terminalSafe(text)))}`, agentCell(agent), width)
 
-/** `▶ Subagent: <description>`: a running subagent that names no phase and sits on none. */
-export const subagentLine = (description: string, width: number): string =>
-  labelledLine(TEXTS.subagent, { text: description, agent: null }, width)
+/** `● now: <text>`: what an agent reports that no task of the plan names; the agent dim at the right edge. */
+export const nowLine = (task: UnplannedTask, width: number, style: TaskStyle): string =>
+  labelledLine(TEXTS.now, task, width, style)
 
-type TaskLook = { mark: string; style: (line: string) => string; suffix: string }
+/** `● Subagent: <description>`: a running subagent that names no phase and sits on none. */
+export const subagentLine = (description: string, width: number, style: TaskStyle): string =>
+  labelledLine(TEXTS.subagent, { text: description, agent: null }, width, style)
 
-/** The mark and the text style of a task: a ticked one green and dim, the one being worked on with its arrow. */
-const taskLook = ({ done }: ChecklistItem, active: ActiveTask | undefined): TaskLook => {
+/**
+ * The mark and the text style of a task: a ticked one green and dim, the one being worked on with its arrow and
+ * otherwise plain like every open task; bold is for headings (lane name, phase title).
+ */
+const taskLook = ({ done }: ChecklistItem, active: ActiveTask | undefined, taskStyle: TaskStyle): TaskLook => {
   if (active) {
-    return {
-      mark: activeArrow(active.guessed),
-      style: (line) => activeTitle(line, active.guessed),
-      suffix: agentSuffix(active.agent),
-    }
+    const style = active.guessed ? PLAIN_TASK : taskStyle
+    return { mark: activeArrow(active.guessed), style, suffix: agentSuffix(active.agent) }
   }
   return done
     ? { mark: paint.green('☑'), style: paint.dim, suffix: '' }
     : { mark: '☐', style: (line) => line, suffix: '' }
 }
 
-/** A closed task as one row, its short name or its text cut at the pane's edge with `…`. */
-const closedTaskRow = (item: ChecklistItem, active: ActiveTask | undefined, width: number): string[] => {
-  const { mark, style } = taskLook(item, active)
-  return [spread(`${mark} ${style(taskTitle(item.text))}`, agentCell(active?.agent ?? null), width)]
-}
+/** What an open task reads as on one row, like `taskTitle`, but a path in backticks stays as a dim addition. */
+const openTaskTitle = (text: string): string =>
+  plain((taskNameOf(text) ?? text).replace(CODE_SPAN, (_, code: string) => paint.dim(code)))
 
-/** A named task opened: its name bold beside the mark, below it the line after the name (`taskBodyOf`) wrapped. */
-const namedTaskRows = (name: string, item: ChecklistItem, look: TaskLook, width: number): string[] => {
-  const body = wrap(plain(taskBodyOf(item.text)), Math.max(width - 2, 1)).map(
-    (line) => `  ${item.done ? paint.dim(line) : line}`,
-  )
-  return [fit(`${look.mark} ${paint.bold(plain(name))}${look.suffix}`, width), ...body]
+/** A closed task as one row, its short name or its text cut at the pane's edge with `…`; an open one's paths dim. */
+const closedTaskRow = (item: ChecklistItem, look: TaskLook, agent: string | null, width: number): string[] => {
+  const title = item.done ? taskTitle(item.text) : openTaskTitle(item.text)
+  return [spread(`${look.mark} ${look.style(title)}`, agentCell(agent), width)]
 }
 
-/** An open task as rows: a named one by `namedTaskRows`, else its whole text wrapped. */
-const openTaskRows = (item: ChecklistItem, active: ActiveTask | undefined, width: number): string[] => {
-  const name = taskNameOf(item.text)
-  const look = taskLook(item, active)
-  return name ? namedTaskRows(name, item, look, width) : markedLines(item.text, look, width)
-}
+/** A line of an opened task's text behind a thin dim rail, two cells in, under the task's mark; dim when ticked. */
+const railLine = (line: string, done: boolean): string => `${RAIL_PREFIX}${done ? paint.dim(line) : line}`
 
 /** A task as a selectable row under its `key`: clickable across every line it takes, the cursor on its first. */
 export const taskFrame = (key: string, rows: string[], context: Pick<LaneContext, 'state' | 'width'>): Frame =>
   rowFrame(key, rows, [], context)
 
+/**
+ * An opened task set as a brief (`taskBrief`): a named one its name bold beside the mark, an unnamed one the brief's
+ * first line; below it the brief behind a rail, then `▸ n more lines`, a row of its own that opens the rest below it.
+ */
+const openedTaskFrame = (
+  key: string,
+  item: ChecklistItem,
+  look: TaskLook,
+  context: Pick<LaneContext, 'state' | 'width'>,
+): Frame => {
+  const { width } = context
+  const name = taskNameOf(item.text)
+  const brief = taskBrief(taskBodyOf(item.text), width - RAIL_CELLS)
+  const head = name ? paint.bold(plain(name)) : look.style(brief.shown[0] ?? '')
+  const below = name ? brief.shown : brief.shown.slice(1)
+  const task = taskFrame(
+    key,
+    [fit(`${look.mark} ${head}${look.suffix}`, width), ...below.map((line) => railLine(line, item.done))],
+    context,
+  )
+  return brief.rest.length === 0 ? task : joinFrames([task, taskRestFrame(key, brief.rest, item.done, context)])
+}
+
+/**
+ * The rest of an opened task's text once opened, right under its brief as one text, then `▸ n more lines` below the
+ * whole text, a row of its own under `taskRestKey`.
+ */
+const taskRestFrame = (
+  key: string,
+  rest: readonly string[],
+  done: boolean,
+  context: Pick<LaneContext, 'state' | 'width'>,
+): Frame => {
+  const restKey = taskRestKey(key)
+  const open = context.state.expanded.has(restKey)
+  const more = `${TASK_INDENT}${paint.dim(`${chevronOf(open)} ${TEXTS.moreLines(rest.length)}`)}`
+  return joinFrames([
+    textFrame(open ? rest.map((line) => railLine(line, done)) : []),
+    rowFrame(restKey, [fit(more, context.width)], [], context),
+  ])
+}
+
+/** A task as its row under the phase's `phaseRowKey`: one line while closed, set as a brief once a click opened it. */
+export const taskRowFrame = (
+  context: Pick<LaneContext, 'state' | 'width' | 'taskStyle'>,
+  phaseRowKey: string,
+  { item, index, active }: PhaseTask,
+): Frame => {
+  const key = itemKey(phaseRowKey, index)
+  const look = taskLook(item, active, context.taskStyle)
+  return context.state.expanded.has(key)
+    ? openedTaskFrame(key, item, look, context)
+    : taskFrame(key, closedTaskRow(item, look, active?.agent ?? null, context.width), context)
+}
+
 /** A checkbox moved to another phase, dim: `→ P9 <text>`. */
 const deferredRow = ({ text, target }: DeferredItem, width: number): string =>
   fit(paint.dim(`${DEFERRED_MARK} ${phaseLabel(target)} ${plain(text)}`), width)
 
-/** The clickable line of a phase's ticked tasks: `▸ <n> ticked · …lists them`, or `▾ …folds them` above the listed ones. */
-const tickedSummaryFrame = (count: number, phaseRowKey: string, width: number, listed: boolean): Frame => ({
-  lines: [
-    fit(paint.dim(`${chevronOf(listed)} ${listed ? TEXTS.tickedFold(count) : TEXTS.tickedSummary(count)}`), width),
-  ],
-  cursorLine: -1,
-  targets: [{ line: 0, from: 0, to: width, key: tickedKey(phaseRowKey), wholeLine: true }],
-})
-
 /**
- * The children of an open phase, one frame per task: open ones first, the `active` ones (by task index) marked, then the ones
- * deferred to another phase, then the ticked ones listed or summed up.
+ * The children of an open phase below its fold row, one frame per task: the open ones first, the `active` ones (by
+ * task index) marked, then the ones deferred to another phase, then the ticked ones, all listed: an opened phase has
+ * no second fold row. The tasks in `shown` stand above already and are left out.
  */
 export const phaseChildren = (
   context: LaneContext,
   phaseRowKey: string,
   phase: PhaseProgress,
   active: ReadonlyMap<number, ActiveTask>,
+  shown: ReadonlySet<number>,
 ): Frame[] => {
-  const { state, width } = context
-  const frameOf = (item: ChecklistItem, index: number): Frame => {
-    const key = itemKey(phaseRowKey, index)
-    const mark = active.get(index)
-    const rows = state.expanded.has(key) ? openTaskRows(item, mark, width) : closedTaskRow(item, mark, width)
-    return taskFrame(key, rows, context)
-  }
+  const frameOf = (item: ChecklistItem, index: number): Frame =>
+    taskRowFrame(context, phaseRowKey, { item, index, active: active.get(index) })
   const framesWhere = (done: boolean): Frame[] =>
-    phase.items.flatMap((item, index) => (item.done === done ? [frameOf(item, index)] : []))
-  const tickedCount = phase.items.filter((item) => item.done).length
-  const summary = tickedCount > 0 ? [tickedSummaryFrame(tickedCount, phaseRowKey, width, state.showDone)] : []
-  const deferred = (phase.deferred ?? []).map((item) => textFrame([deferredRow(item, width)]))
-  return [...framesWhere(false), ...deferred, ...summary, ...(state.showDone ? framesWhere(true) : [])]
+    phase.items.flatMap((item, index) => (item.done === done && !shown.has(index) ? [frameOf(item, index)] : []))
+  const deferred = (phase.deferred ?? []).map((item) => textFrame([deferredRow(item, context.width)]))
+  return [...framesWhere(false), ...deferred, ...framesWhere(true)]
 }