jackherd 1.8.1 → 1.9.0

package/src/plans/lane-summary.ts

@@ -6,32 +6,31 @@ import {
   type PhaseProgress,
   type PlanPhase,
   type PlansByHref,
-  parseDependencyTable,
   phaseProgress,
-  phaseWaves,
 } from '../plan-format'
-import type { PlanLanguage } from '../vocabulary'
+import type { TaskSignal } from '../task-signals/types'
+import { type ActiveTask, assignSignals, freshSignals, type UnplannedTask } from './active-tasks'
 import { type ActivityTimes, activityKey } from './current-phase'
-import { currentTasks, type TaskSignal } from './current-task'
+import { currentTasks, type TaskActivity } from './current-task'
 
 /**
- * A phase the lane works on now: an open one whose ticks or task lines moved less than `STALE_ACTIVITY_MINUTES` ago.
- * `stepIndex` is the newest step of the lane that shows it, null for a phase no step shows; `minutesAgo` the whole
- * minutes since that movement.
+ * A phase the lane works on now: an open one ticked less than `STALE_ACTIVITY_MINUTES` ago, one an agent reports, or
+ * one with a ticked task. `stepIndex` is the newest step of the lane that shows it, null for a phase no step shows;
+ * `minutesAgo` the whole minutes since its last tick or report, null when the herd saw neither.
  */
 export type ActivePhase = {
   phase: PhaseProgress
   stepIndex: number | null
-  minutesAgo: number
-  /** The index of the task the phase is on in its checkboxes (`currentTasks`); null when none is open. */
-  taskIndex: number | null
+  minutesAgo: number | null
+  /**
+   * The tasks the phase is on: the ones agents reported, else the one `currentTasks` guesses (marked `guessed`); empty
+   * when no task is open.
+   */
+  tasks: ActiveTask[]
 }
 
-/** The phases that come next: the open ones of the next wave, `wave` its 1-based number, null without a dependency table. */
-export type NextPhases = { wave: number | null; phaseIds: string[] }
-
-/** Open phases after the next ones; `planTitle` is null for the lane's current plan, the board's title for another. */
-export type LaterPhases = { planTitle: string | null; phaseIds: string[] }
+/** Open phases that do not run, by number; `planTitle` is null for the lane's current plan, the board's title for another. */
+export type WaitingPhases = { planTitle: string | null; phaseIds: string[] }
 
 export type FinishedPhase = { id: string; unmerged: boolean }
 
@@ -41,35 +40,36 @@ export type UnwrittenPhase = { id: string; missing: boolean }
 /** Checkboxes and phases over every plan of the lane, a phase counted when it has a checkbox. */
 export type PlanTally = { done: number; total: number; phasesDone: number; phases: number }
 
-/** A lane as the herd sums it up: what runs now, what comes next and after, what is finished, and how far it is. */
+/** A lane as the herd sums it up: what runs now, what waits, what is finished, and how far it is. */
 export type LaneSummary = {
-  /** The running phases, the one moved last first. */
+  /** The running phases by number, never by recency, so a new movement reorders nothing. */
   active: ActivePhase[]
   /** The open phase of the current plan moved last, at any age; null while none has a time. */
   latest: PhaseProgress | null
-  next: NextPhases | null
-  later: LaterPhases[]
+  /** The open phases of the current plan that do not run, then the open phases of the lane's other plans. */
+  waiting: WaitingPhases[]
   finished: FinishedPhase[]
   unwritten: UnwrittenPhase[]
   tally: PlanTally
+  /** What agents report doing that no open task of the plan names. */
+  unplanned: UnplannedTask[]
 }
 
 /**
- * `phases` are the lane's plans as it reads them (the base merged with its worktree), `texts` their texts for the
- * dependency tables; a plan missing from `phases` falls back to the phases the lane's steps show.
+ * `phases` are the lane's plans as it reads them (the base merged with its worktree); a plan missing from `phases`
+ * falls back to the phases the lane's steps show.
  */
 export type SummaryInput = {
   progress: LaneProgress
   phases: Readonly<PlansByHref>
-  texts: Readonly<Record<string, string>>
   activity: ActivityTimes
-  /** The language the plans were written in, for reading their dependency tables; the herd's words are English. */
-  language: PlanLanguage
-  /** Hints at the task a phase is on, by phase id; none when absent, and no source writes one yet. */
-  signals?: readonly TaskSignal[]
+  /** Hints at the task a phase is on, guessed from the words of the lane's agents; the fallback while nothing is reported. */
+  guesses?: readonly TaskActivity[]
+  /** What the lane's agents report doing (task lists, `jh task`), matched to open tasks of the current plan. */
+  reported?: readonly TaskSignal[]
 }
 
-/** Minutes without a tick or a new task line after which a phase no longer runs. */
+/** Minutes without a tick after which a phase no longer runs, unless an agent reports it. */
 export const STALE_ACTIVITY_MINUTES = 20
 
 const MINUTE = 60_000
@@ -92,9 +92,27 @@ const stepPhases = ({ steps }: LaneProgress, href: string): PhaseProgress[] => {
   return shown.filter((phase, index) => shown.findIndex(({ id }) => id === phase.id) === index)
 }
 
+const SUB_PHASE_LETTERS = /[a-z]+$/i
+
+/** The ids the lane's steps on `href` name, a row's repeats and the phases it worked on without a row included. */
+const namedIds = ({ steps }: LaneProgress, href: string): Set<string> =>
+  new Set(
+    steps.flatMap(({ step }) => (step.planHref === href ? [...step.phaseIds, ...(step.namedPhaseIds ?? [])] : [])),
+  )
+
+/** A plan phase the lane names: by its own id, or a sub-phase (`10c`) of a phase it names (`P10`). */
+const isNamed = (id: string, named: ReadonlySet<string>): boolean =>
+  named.has(id) || named.has(id.replace(SUB_PHASE_LETTERS, ''))
+
+/**
+ * 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.
+ */
 const phasesOf = (input: SummaryInput, href: string): PhaseProgress[] => {
   const plan: readonly PlanPhase[] | undefined = input.phases[href]
-  return plan ? plan.map(({ id }) => phaseProgress(plan, id)) : stepPhases(input.progress, href)
+  if (!plan) return stepPhases(input.progress, href)
+  const named = namedIds(input.progress, href)
+  return plan.filter(({ id }) => isNamed(id, named)).map(({ id }) => phaseProgress(plan, id))
 }
 
 const newestStepShowing = ({ steps }: LaneProgress, href: string, id: string): number | null => {
@@ -106,6 +124,17 @@ const newestStepShowing = ({ steps }: LaneProgress, href: string, id: string): n
 
 type TimedPhase = { phase: PhaseProgress; minutesAgo: number }
 
+type RunningPhase = { phase: PhaseProgress; minutesAgo: number | null }
+
+/**
+ * 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`.
+ */
+const isStarted = ({ items }: PhaseProgress): boolean => {
+  const tasks = items.filter(({ gate }) => !gate)
+  return tasks.some(({ done }) => done) && tasks.some(({ done }) => !done)
+}
+
 /** The open phases with a time of their last movement, the one moved last first; a phase without a time is absent. */
 const timedPhases = (input: SummaryInput, href: string, phases: PhaseProgress[], now: number): TimedPhase[] =>
   phases
@@ -116,42 +145,77 @@ const timedPhases = (input: SummaryInput, href: string, phases: PhaseProgress[],
     })
     .sort((first, second) => first.minutesAgo - second.minutesAgo)
 
-/** The timed phases that moved less than `STALE_ACTIVITY_MINUTES` ago, each with the task it is on. */
-const activeOf = (input: SummaryInput, href: string, timed: TimedPhase[], now: number): ActivePhase[] => {
-  const running = timed.filter(({ minutesAgo }) => minutesAgo < STALE_ACTIVITY_MINUTES)
-  const tasks = currentTasks(
-    running.map(({ phase }) => phase),
-    input.signals ?? [],
-    now,
-    STALE_ACTIVITY_MINUTES * MINUTE,
-  )
-  return running.map(({ phase, minutesAgo }) => ({
-    phase,
-    stepIndex: newestStepShowing(input.progress, href, phase.id),
-    minutesAgo,
-    taskIndex: tasks.get(phase.id) ?? null,
-  }))
+const newest = (times: readonly number[]): number | null => (times.length > 0 ? Math.max(...times) : null)
+
+const minutesSince = (at: number, now: number): number => Math.max(Math.floor((now - at) / MINUTE), 0)
+
+const isListed = (listed: readonly RunningPhase[], phase: PhaseProgress): boolean =>
+  listed.some((each) => each.phase.id === phase.id)
+
+/** The open phases a reported task names that are not `listed` yet, aged from the newest report. */
+const reportedPhases = (
+  phases: PhaseProgress[],
+  reported: ReadonlyMap<string, ActiveTask[]>,
+  listed: readonly RunningPhase[],
+  now: number,
+): RunningPhase[] =>
+  phases
+    .filter((phase) => isPhaseOpen(phase) && reported.has(phase.id) && !isListed(listed, phase))
+    .map((phase) => {
+      const startedAt = newest((reported.get(phase.id) ?? []).flatMap((task) => task.startedAt ?? []))
+      return { phase, minutesAgo: startedAt === null ? 0 : minutesSince(startedAt, now) }
+    })
+
+/** 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[] =>
+  phases
+    .filter((phase) => isPhaseOpen(phase) && isStarted(phase) && !isListed(listed, phase))
+    .map((phase) => ({ phase, minutesAgo: timed.find((each) => each.phase.id === phase.id)?.minutesAgo ?? null }))
+
+/**
+ * The phases that run: the timed ones ticked less than `STALE_ACTIVITY_MINUTES` ago, the phases a reported task
+ * names, then every other open phase with a ticked task (`isStarted`), with the age of its last tick when one is
+ * known, else none (17:38). A phase only written down, without a tick or a report, waits.
+ */
+const runningPhases = (
+  timed: TimedPhase[],
+  phases: PhaseProgress[],
+  reported: ReadonlyMap<string, ActiveTask[]>,
+  now: number,
+): RunningPhase[] => {
+  const moved = timed.filter(({ minutesAgo }) => minutesAgo < STALE_ACTIVITY_MINUTES)
+  const listed = [...moved, ...reportedPhases(phases, reported, moved, now)]
+  return [...listed, ...startedPhases(phases, timed, listed)]
 }
 
 /**
- * The open phases of the first wave that holds one not running; without a dependency table, phases run one after the
- * other and the next is the first open one not running. Null when nothing is left, or no wave holds what is left.
+ * The task the herd guesses for each of the `phases` from the words of the lane's agents (`currentTasks`); the caller
+ * passes no phase while an agent reports, so a lane with a report guesses nothing.
  */
-const nextOf = (
+const guessedTasks = (input: SummaryInput, phases: PhaseProgress[], now: number): ReadonlyMap<string, number> =>
+  currentTasks(phases, input.guesses ?? [], now, STALE_ACTIVITY_MINUTES * MINUTE)
+
+/** The running phases, each with the tasks agents reported on it, else its task in `guessed`, marked as guessed. */
+const activeOf = (
   input: SummaryInput,
   href: string,
-  phases: PhaseProgress[],
-  running: ReadonlySet<string>,
-): NextPhases | null => {
-  const waiting = phases.filter((phase) => isPhaseOpen(phase) && !running.has(phase.id)).map(({ id }) => id)
-  const text = input.texts[href]
-  const rows = text === undefined ? null : parseDependencyTable(text, input.language)
-  if (rows === null) return waiting.length > 0 ? { wave: null, phaseIds: [waiting[0]] } : null
-  const done = new Set(phases.filter(isPhaseFinished).map(({ id }) => id))
-  const waves = phaseWaves(rows, done)
-  const index = waves.findIndex((wave) => wave.some((id) => waiting.includes(id)))
-  return index === -1 ? null : { wave: index + 1, phaseIds: waves[index].filter((id) => waiting.includes(id)) }
-}
+  running: RunningPhase[],
+  reported: ReadonlyMap<string, ActiveTask[]>,
+  guessed: ReadonlyMap<string, number>,
+): ActivePhase[] =>
+  running
+    .map(({ phase, minutesAgo }) => {
+      const guess = guessed.get(phase.id)
+      return {
+        phase,
+        stepIndex: newestStepShowing(input.progress, href, phase.id),
+        minutesAgo,
+        tasks:
+          reported.get(phase.id) ??
+          (guess === undefined ? [] : [{ index: guess, agent: null, guessed: true, startedAt: null }]),
+      }
+    })
+    .sort((first, second) => first.phase.id.localeCompare(second.phase.id, undefined, { numeric: true }))
 
 const tallyOf = (phases: PhaseProgress[]): PlanTally => ({
   done: phases.reduce((sum, phase) => sum + phase.done, 0),
@@ -164,21 +228,21 @@ const titleOf = ({ steps }: LaneProgress, href: string): string =>
   steps.find(({ step }) => step.planHref === href)?.step.planTitle ?? href
 
 /** The open phases of the lane's other plans, each plan by its title. */
-const otherPlans = (input: SummaryInput, hrefs: string[]): LaterPhases[] =>
+const otherPlans = (input: SummaryInput, hrefs: string[]): WaitingPhases[] =>
   hrefs.flatMap((href) => {
     const open = phasesOf(input, href).filter(isPhaseOpen)
     return open.length > 0 ? [{ planTitle: titleOf(input.progress, href), phaseIds: open.map(({ id }) => id) }] : []
   })
 
-/** The open phases of the current plan that neither run nor come next, then the open phases of the lane's other plans. */
-const laterOf = (
+/** The open phases of the current plan that do not run, by number, then the open phases of the lane's other plans. */
+const waitingOf = (
   input: SummaryInput,
   href: string,
   phases: PhaseProgress[],
-  upcoming: ReadonlySet<string>,
-): LaterPhases[] => {
+  running: ReadonlySet<string>,
+): WaitingPhases[] => {
   const waiting = phases
-    .filter((phase) => isPhaseOpen(phase) && !upcoming.has(phase.id))
+    .filter((phase) => isPhaseOpen(phase) && !running.has(phase.id))
     .map(({ id }) => id)
     .sort((first, second) => first.localeCompare(second, undefined, { numeric: true }))
   const others = otherPlans(
@@ -193,30 +257,33 @@ const finishedOf = (phases: PhaseProgress[]): FinishedPhase[] =>
   phases.filter(isPhaseFinished).map((phase) => ({ id: phase.id, unmerged: isTickedUnmerged(phase) }))
 
 /**
- * The lane summed up over its plans at `now`: the open phases running in its current plan (moved less than
- * `STALE_ACTIVITY_MINUTES` ago; a phase without a time of its last movement never runs), the open phase moved last,
- * the next wave's open phases, the other open phases, the finished ones (marked when not merged yet), the phases its
- * rows name with nothing to run, and the tally over every plan of the lane. A phase ticked to the end, review gate
+ * The lane summed up over its plans at `now`: the open phases running in its current plan (`runningPhases`), the open
+ * phase moved last, the open phases that wait, the finished ones (marked when not merged yet), the phases its rows
+ * name with nothing to run, and the tally over every plan of the lane. A phase ticked to the end, review gate
  * included, is finished, never running.
  */
 export const laneSummary = (input: SummaryInput, now: number): LaneSummary => {
   const href = focusHref(input.progress)
   const tally = tallyOf(planHrefs(input.progress).flatMap((each) => phasesOf(input, each)))
-  if (href === null) return { active: [], latest: null, next: null, later: [], finished: [], unwritten: [], tally }
+  if (href === null) {
+    return { active: [], latest: null, waiting: [], finished: [], unwritten: [], tally, unplanned: [] }
+  }
   const phases = phasesOf(input, href)
   const timed = timedPhases(input, href, phases, now)
-  const active = activeOf(input, href, timed, now)
-  const running = new Set(active.map(({ phase }) => phase.id))
-  const next = nextOf(input, href, phases, running)
+  const fresh = freshSignals(input.reported ?? [], newest(Object.values(input.activity)))
+  const { byPhase, unplanned } = assignSignals(phases, fresh)
+  const running = runningPhases(timed, phases, byPhase, now)
+  const guessable = fresh.length > 0 ? [] : running.map(({ phase }) => phase).filter(({ id }) => !byPhase.has(id))
+  const active = activeOf(input, href, running, byPhase, guessedTasks(input, guessable, now))
   return {
     active,
     latest: timed[0]?.phase ?? null,
-    next,
-    later: laterOf(input, href, phases, new Set([...running, ...(next?.phaseIds ?? [])])),
+    waiting: waitingOf(input, href, phases, new Set(active.map(({ phase }) => phase.id))),
     finished: finishedOf(phases),
     unwritten: stepPhases(input.progress, href)
       .filter((phase) => !isWritten(phase))
       .map(({ id, title }) => ({ id, missing: title === null })),
     tally,
+    unplanned,
   }
 }

package/src/plans/lane-tickets.ts

@@ -34,6 +34,21 @@ const onceById = (tickets: readonly SourceTicket[]): SourceTicket[] =>
 
 const badgeOf = ({ lane: _lane, ...badge }: SourceTicket): TicketBadge => badge
 
+/**
+ * A pull request title without the lane ticket it starts with (`T-1 …`, `[T-1] …`, `T-1: …`, `T-1 - …`): the ticket
+ * stands under the lane's links already. A key inside the title, a longer key or a title that is the key alone stays.
+ */
+export const withoutTicketKey = (title: string, ids: readonly string[]): string => {
+  for (const id of ids) {
+    const lead = title.startsWith(`[${id}]`) ? `[${id}]` : title.startsWith(id) ? id : ''
+    const rest = title.slice(lead.length)
+    if (lead === '' || isWordCharacter(rest[0])) continue
+    const stripped = rest.replace(/^\s*[:-]?\s+|^\s*:\s*/, '')
+    if (stripped !== '' && stripped !== rest) return stripped
+  }
+  return title
+}
+
 /** What the lane's board rows say of it beside its name, for finding ticket ids: the text of each row. */
 export const boardRowTexts = (lane: SprintLane): string[] => lane.steps.map(({ label }) => label)
 

package/src/plans/layout-phase.ts

@@ -1,8 +1,10 @@
 import type { ChecklistItem, DeferredItem, LaneProgress, PhaseProgress } from '../plan-format'
 import { onlyDocumentationOpen, phaseLabel } from '../plan-format'
-import { fit, padVisible, paint, wrap } from '../terminal/text'
+import { terminalSafe } from '../plan-format/terminal-text'
+import { fit, padVisible, paint, spread, wrap } 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 { LaneTickets } from './lane-tickets'
 import type { LinkChip } from './link-chips'
@@ -26,13 +28,14 @@ export type LaneContext = {
 }
 
 export const ACTIVE_MARK = '▶'
+export const GUESSED_MARK = '▷'
 export const DEFERRED_MARK = '→'
 export const COLUMN_SEPARATOR = '  '
 export const MIN_TITLE_WIDTH = 8
 
 /** 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 COUNT_CELL_WIDTH = COUNT_MARK_WIDTH + 1 + BLANK_COUNT.length
@@ -87,26 +90,62 @@ export const modelMark = (model: PhaseModel | undefined): string =>
     : ''
 
 /** `text` wrapped beside a one-cell `mark`, each line in `style`; follow-up lines indent under the text. */
-const markedLines = (text: string, mark: string, style: (line: string) => string, width: number): string[] =>
-  wrap(plain(text), Math.max(width - 2, 1)).map((line, index) => `${index > 0 ? ' ' : mark} ${style(line)}`)
+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.
+ */
+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)) : '')
 
-/** The mark and the text style of a task: a ticked one green and dim, the one being worked on yellow and bold. */
-const taskLook = ({ done }: ChecklistItem, active: boolean): { mark: string; style: (line: string) => string } => {
-  if (active) return { mark: paint.yellow(ACTIVE_MARK), style: paint.bold }
-  return done ? { mark: paint.green('☑'), style: paint.dim } : { mark: '☐', style: (line) => line }
+/** Two cells: a task row hangs under its phase's label, which an arrow would otherwise push right. */
+export const TASK_INDENT = '  '
+
+/** `▶ now: <text>`: what an agent reports that no task of the plan names; the agent dim at the right edge. */
+export const nowLine = ({ text, agent }: UnplannedTask, width: number): string =>
+  spread(`${activeArrow(false)} ${TEXTS.now} ${paint.bold(plain(terminalSafe(text)))}`, agentCell(agent), width)
+
+type TaskLook = { mark: string; style: (line: string) => string; suffix: string }
+
+/** 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 => {
+  if (active) {
+    return {
+      mark: activeArrow(active.guessed),
+      style: (line) => activeTitle(line, active.guessed),
+      suffix: agentSuffix(active.agent),
+    }
+  }
+  return done
+    ? { mark: paint.green('☑'), style: paint.dim, suffix: '' }
+    : { mark: '☐', style: (line) => line, suffix: '' }
 }
 
 /** A closed task as one row, cut at the pane's edge with `…`. */
-const closedTaskRow = (item: ChecklistItem, active: boolean, width: number): string[] => {
+const closedTaskRow = (item: ChecklistItem, active: ActiveTask | undefined, width: number): string[] => {
   const { mark, style } = taskLook(item, active)
-  return [fit(`${mark} ${style(plain(item.text))}`, width)]
+  return [spread(`${mark} ${style(plain(item.text))}`, agentCell(active?.agent ?? null), width)]
 }
 
 /** An open task as rows: its whole text wrapped. */
-const openTaskRows = (item: ChecklistItem, active: boolean, width: number): string[] => {
-  const { mark, style } = taskLook(item, active)
-  return markedLines(item.text, mark, style, width)
-}
+const openTaskRows = (item: ChecklistItem, active: ActiveTask | undefined, width: number): string[] =>
+  markedLines(item.text, taskLook(item, active), width)
 
 /** 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 =>
@@ -123,20 +162,20 @@ const tickedSummaryFrame = (count: number, phaseRowKey: string, width: number):
 })
 
 /**
- * The children of an open phase, one frame per task: open ones first, `active` marked among them, then the ones
+ * 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.
  */
 export const phaseChildren = (
   context: LaneContext,
   phaseRowKey: string,
   phase: PhaseProgress,
-  active: ChecklistItem | null,
+  active: ReadonlyMap<number, ActiveTask>,
 ): Frame[] => {
   const { state, width } = context
   const frameOf = (item: ChecklistItem, index: number): Frame => {
     const key = itemKey(phaseRowKey, index)
-    const isActive = item === active
-    const rows = state.expanded.has(key) ? openTaskRows(item, isActive, width) : closedTaskRow(item, isActive, width)
+    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 framesWhere = (done: boolean): Frame[] =>