jackherd 1.8.1 → 1.10.0

package/src/plans/lane-summary.ts

@@ -1,39 +1,51 @@
 import {
   isPhaseFinished,
   isPhaseOpen,
-  isTickedUnmerged,
   type LaneProgress,
   type PhaseProgress,
   type PlanPhase,
   type PlansByHref,
-  parseDependencyTable,
   phaseProgress,
-  phaseWaves,
 } from '../plan-format'
-import type { PlanLanguage } from '../vocabulary'
+import { MS_PER_MINUTE } from '../plan-format/clock'
+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'
+import { isNamedBy } from './phase-ids'
+import { signalledPhase } from './signalled-phase'
+import {
+  type PhaselessReview,
+  type ReviewType,
+  type SubagentPhase,
+  type SubagentPhaseRun,
+  subagentPhases,
+} from './subagent-phases'
+import { type DescribedSubagent, subagentTaskPlacements } from './subagent-tasks'
 
 /**
- * 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[] }
+/** A phase with the step that shows it (null for none), which keys its row (`phaseKey`). */
+export type PlacedPhase = { phase: PhaseProgress; stepIndex: number | null }
 
-/** 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 }
+export type FinishedPhase = { id: string }
 
 /** A phase the lane's board rows name that has nothing to run: `missing` when the plan lacks it, else it has no checkbox. */
 export type UnwrittenPhase = { id: string; missing: boolean }
@@ -41,39 +53,56 @@ 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 phase the lane's newest report or its branch names (`signalledPhase`); it runs and the lane line names it. */
+  signalled: PhaseProgress | null
+  /** The open phases of the current plan that do not run, then the open phases of the lane's other plans. */
+  waiting: WaitingPhases[]
+  /** The phases behind `waiting`, in its order, for the rows `next` opens to. */
+  waitingPhases: PlacedPhase[]
   finished: FinishedPhase[]
+  /** The phases behind `finished`, for the rows `✓` opens to. */
+  finishedPhases: PlacedPhase[]
   unwritten: UnwrittenPhase[]
   tally: PlanTally
+  /** What agents report doing that no open task of the plan names. */
+  unplanned: UnplannedTask[]
+  /** What the running subagents without a phase in their description work on, as they described it. */
+  subagentTasks: string[]
 }
 
 /**
- * `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[]
+  /** The phases the descriptions of the lane's running subagents name; a signal like a report, never a tick. */
+  subagents?: readonly SubagentPhaseRun[]
+  /** The descriptions of the running subagents that name no phase; the folded lane shows them as tasks. */
+  subagentTasks?: readonly string[]
+  /** The running reviews that name no phase; they sit on the `signalled` phase, else show as tasks like `subagentTasks`. */
+  phaselessReviews?: readonly PhaselessReview[]
+  /** The running subagents that are no review; one whose description starts with a task's short name sits on it (`subagentTaskPlacements`). */
+  describedSubagents?: readonly DescribedSubagent[]
+  /** The branch checked out in the lane's worktree; a phase it names (`branchPhaseId`) is current while no report names one. */
+  branch?: string | null
 }
 
-/** 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
-
 const isWritten = ({ total }: PhaseProgress): boolean => total > 0
 
 const planHrefs = ({ steps }: LaneProgress): string[] => [
@@ -92,9 +121,21 @@ const stepPhases = ({ steps }: LaneProgress, href: string): PhaseProgress[] => {
   return shown.filter((phase, index) => shown.findIndex(({ id }) => id === phase.id) === index)
 }
 
+/** 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 ?? [])] : [])),
+  )
+
+/**
+ * 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 }) => isNamedBy(id, named)).map(({ id }) => phaseProgress(plan, id))
 }
 
 const newestStepShowing = ({ steps }: LaneProgress, href: string, id: string): number | null => {
@@ -106,53 +147,209 @@ 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)
+}
+
+const minutesSince = (at: number, now: number): number => Math.max(Math.floor((now - at) / MS_PER_MINUTE), 0)
+
 /** 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
     .filter(isPhaseOpen)
     .flatMap((phase) => {
       const at = input.activity[activityKey(href, phase.id)]
-      return at === undefined ? [] : [{ phase, minutesAgo: Math.max(Math.floor((now - at) / MINUTE), 0) }]
+      return at === undefined ? [] : [{ phase, minutesAgo: minutesSince(at, now) }]
     })
     .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 isListed = (listed: readonly RunningPhase[], phase: PhaseProgress): boolean =>
+  listed.some((each) => each.phase.id === phase.id)
+
+/** What names a phase as running besides its ticks, by phase id: the tasks agents reported and the subagents at work. */
+type PhaseSignals = {
+  reported: ReadonlyMap<string, ActiveTask[]>
+  subagents: ReadonlyMap<string, SubagentPhase>
 }
 
+/** When the newest report or running subagent of a phase began, in milliseconds; null for none. */
+const reportedAt = (id: string, { reported, subagents }: PhaseSignals): number | null => {
+  const subagent = subagents.get(id)
+  return newest([
+    ...(reported.get(id) ?? []).flatMap((task) => task.startedAt ?? []),
+    ...(subagent === undefined ? [] : [subagent.at]),
+  ])
+}
+
+/** The open phases a reported task or a running subagent names that are not `listed` yet, aged from the newest of them. */
+const reportedPhases = (
+  phases: PhaseProgress[],
+  signals: PhaseSignals,
+  listed: readonly RunningPhase[],
+  now: number,
+): RunningPhase[] =>
+  phases
+    .filter(
+      (phase) =>
+        isPhaseOpen(phase) &&
+        (signals.reported.has(phase.id) || signals.subagents.has(phase.id)) &&
+        !isListed(listed, phase),
+    )
+    .map((phase) => {
+      const startedAt = reportedAt(phase.id, signals)
+      return { phase, minutesAgo: startedAt === null ? 0 : minutesSince(startedAt, now) }
+    })
+
 /**
- * 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.
+ * Whether a text names the review type as a word (`/security-audit`, `` `uncle-bob` ``): `review` is not named by
+ * `skill-review` or `Review-Gate`. The types hold no character a pattern reads specially.
  */
-const nextOf = (
-  input: SummaryInput,
-  href: string,
+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
+ * 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[] => {
+  const isOpenGate = (item: PhaseProgress['items'][number]): boolean => item.gate === true && !item.done
+  const named = items.findIndex((item) => isOpenGate(item) && namesReview(item.text, review))
+  const index = named === -1 ? items.findIndex(isOpenGate) : named
+  return index === -1 ? [] : [{ index, agent: null, guessed: false, startedAt: at }]
+}
+
+/** Adds `tasks` to the phase's tasks in `merged`, each task once. */
+const addTasks = (merged: Map<string, ActiveTask[]>, phaseId: string, tasks: readonly ActiveTask[]): void => {
+  const known = merged.get(phaseId) ?? []
+  merged.set(phaseId, [...known, ...tasks.filter(({ index }) => !known.some((task) => task.index === index))])
+}
+
+/** The reported tasks with the gate box each running review of a phase sits on added, unless a report names it already. */
+const withReviewTasks = (
+  reported: ReadonlyMap<string, ActiveTask[]>,
   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)) }
+  subagents: ReadonlyMap<string, SubagentPhase>,
+): Map<string, ActiveTask[]> => {
+  const merged = new Map(reported)
+  for (const phase of phases) {
+    const found = subagents.get(phase.id)
+    if (!found) continue
+    for (const review of found.reviews) addTasks(merged, phase.id, reviewTask(phase, review, found.at))
+  }
+  return merged
+}
+
+/** The reported tasks with the tasks the subagents sit on added (`subagentTaskPlacements`), unless a report names them already. */
+const withTasks = (
+  reported: ReadonlyMap<string, ActiveTask[]>,
+  added: ReadonlyMap<string, ActiveTask[]>,
+): Map<string, ActiveTask[]> => {
+  const merged = new Map(reported)
+  for (const [phaseId, tasks] of added) addTasks(merged, phaseId, tasks)
+  return merged
+}
+
+/** The signalled phase when a review can sit on it: one with an open gate box, else none. */
+const reviewPhaseOf = (signalled: PhaseProgress | null): PhaseProgress | null =>
+  signalled?.items.some((item) => item.gate && !item.done) ? signalled : null
+
+/**
+ * The runs of the lane's subagents, its reviews that name no phase placed on the `signalled` phase while its gate has
+ * an open box; otherwise they stay unplaced and show as tasks (`unplacedTasks`), so a running review never vanishes.
+ */
+const placedRuns = (input: SummaryInput, signalled: PhaseProgress | null): SubagentPhaseRun[] => {
+  const phase = reviewPhaseOf(signalled)
+  return [
+    ...(input.subagents ?? []),
+    ...(phase === null
+      ? []
+      : (input.phaselessReviews ?? []).map(({ review, at }) => ({ ids: [phase.id], review, at }))),
+  ]
+}
+
+/**
+ * The descriptions of the subagents that name no phase and sit on no task (`placed`), then those of the reviews no
+ * signalled phase takes.
+ */
+const unplacedTasks = (input: SummaryInput, signalled: PhaseProgress | null, placed: readonly string[]): string[] => [
+  ...(input.subagentTasks ?? []).filter((description) => !placed.includes(description)),
+  ...(reviewPhaseOf(signalled) === null
+    ? (input.phaselessReviews ?? []).flatMap(({ description }) => (description === null ? [] : [description]))
+    : []),
+]
+
+/** 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 signalled phase when no other source lists it yet, aged from its last tick when one is known. */
+const signalledRunning = (
+  signalled: PhaseProgress | null,
+  timed: TimedPhase[],
+  listed: readonly RunningPhase[],
+): RunningPhase[] =>
+  signalled && !isListed(listed, signalled)
+    ? [{ phase: signalled, minutesAgo: timed.find((each) => each.phase.id === signalled.id)?.minutesAgo ?? null }]
+    : []
+
+/**
+ * The phases that run: the timed ones ticked less than `STALE_ACTIVITY_MINUTES` ago, 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.
+ */
+const runningPhases = (
+  timed: TimedPhase[],
+  phases: PhaseProgress[],
+  signals: PhaseSignals & { signalled: PhaseProgress | null },
+  now: number,
+): RunningPhase[] => {
+  const moved = timed.filter(({ minutesAgo }) => minutesAgo < STALE_ACTIVITY_MINUTES)
+  const reported = [...moved, ...reportedPhases(phases, signals, moved, now)]
+  const listed = [...reported, ...signalledRunning(signals.signalled, timed, reported)]
+  return [...listed, ...startedPhases(phases, timed, listed)]
 }
 
+/**
+ * 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 guessedTasks = (input: SummaryInput, phases: PhaseProgress[], now: number): ReadonlyMap<string, number> =>
+  currentTasks(phases, input.guesses ?? [], now, STALE_ACTIVITY_MINUTES * MS_PER_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,
+  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),
   total: phases.reduce((sum, phase) => sum + phase.total, 0),
@@ -164,59 +361,137 @@ 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 = (
+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)
+
+const otherHrefs = (input: SummaryInput, href: string): string[] =>
+  planHrefs(input.progress).filter((each) => each !== href)
+
+/** 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[] => {
-  const waiting = phases
-    .filter((phase) => isPhaseOpen(phase) && !upcoming.has(phase.id))
-    .map(({ id }) => id)
-    .sort((first, second) => first.localeCompare(second, undefined, { numeric: true }))
-  const others = otherPlans(
-    input,
-    planHrefs(input.progress).filter((each) => each !== href),
-  )
-  return [...(waiting.length > 0 ? [{ planTitle: null, phaseIds: waiting }] : []), ...others]
+  running: ReadonlySet<string>,
+): WaitingPhases[] => {
+  const waiting = waitingIn(phases, running).map(({ id }) => id)
+  return [
+    ...(waiting.length > 0 ? [{ planTitle: null, phaseIds: waiting }] : []),
+    ...otherPlans(input, otherHrefs(input, href)),
+  ]
 }
 
-/** The finished phases of the current plan, each marked while its ticks are not merged. */
+const placedIn =
+  (progress: LaneProgress, href: string) =>
+  (phase: PhaseProgress): PlacedPhase => ({ phase, stepIndex: newestStepShowing(progress, href, phase.id) })
+
+/** The phases behind `waitingOf`, in its order, each with the step that shows it. */
+const waitingPlaced = (
+  input: SummaryInput,
+  href: string,
+  phases: PhaseProgress[],
+  running: ReadonlySet<string>,
+): PlacedPhase[] => [
+  ...waitingIn(phases, running).map(placedIn(input.progress, href)),
+  ...otherHrefs(input, href).flatMap((other) =>
+    phasesOf(input, other).filter(isPhaseOpen).map(placedIn(input.progress, other)),
+  ),
+]
+
+/** The finished phases of the current plan. */
 const finishedOf = (phases: PhaseProgress[]): FinishedPhase[] =>
-  phases.filter(isPhaseFinished).map((phase) => ({ id: phase.id, unmerged: isTickedUnmerged(phase) }))
+  phases.filter(isPhaseFinished).map((phase) => ({ id: phase.id }))
+
+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))
+  return {
+    waiting: waitingOf(input, href, phases, running),
+    waitingPhases: waitingPlaced(input, href, phases, running),
+    finished: finishedOf(phases),
+    finishedPhases: phases.filter(isPhaseFinished).map(placedIn(input.progress, href)),
+    unwritten: stepPhases(input.progress, href)
+      .filter((phase) => !isWritten(phase))
+      .map(({ id, title }) => ({ id, missing: title === null })),
+  }
+}
+
+type ActiveSources = {
+  phases: PhaseProgress[]
+  timed: TimedPhase[]
+  /** The tasks agents reported, by phase id. */
+  reported: ReadonlyMap<string, ActiveTask[]>
+  /** Whether any report is fresh; the herd guesses no task then. */
+  anyFresh: boolean
+  signalled: PhaseProgress | null
+  /** The runs of the lane's subagents, the reviews that name no phase placed (`placedRuns`). */
+  subagents: readonly SubagentPhaseRun[]
+}
+
+/** 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 named = subagentPhases(phases, sources.subagents)
+  const running = runningPhases(timed, phases, { reported, subagents: named, signalled }, now)
+  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))
+}
 
 /**
- * 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, 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) {
+    const subagentTasks = unplacedTasks(input, null, [])
+    return {
+      active: [],
+      latest: null,
+      signalled: null,
+      waiting: [],
+      waitingPhases: [],
+      finished: [],
+      finishedPhases: [],
+      unwritten: [],
+      tally,
+      unplanned: [],
+      subagentTasks,
+    }
+  }
   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 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 active = activePhases(input, href, sources, now)
   return {
     active,
     latest: timed[0]?.phase ?? null,
-    next,
-    later: laterOf(input, href, phases, new Set([...running, ...(next?.phaseIds ?? [])])),
-    finished: finishedOf(phases),
-    unwritten: stepPhases(input.progress, href)
-      .filter((phase) => !isWritten(phase))
-      .map(({ id, title }) => ({ id, missing: title === null })),
+    signalled,
+    ...restingOf(input, href, phases, active),
     tally,
+    unplanned,
+    subagentTasks: unplacedTasks(input, signalled, onTasks.placed),
   }
 }

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)