jackherd 1.8.0 → 1.9.0

package/src/plans/current-task.ts

@@ -1,10 +1,12 @@
+import { parseLogEntry } from '../context/session-log'
 import type { PlanPhase } from '../plan-format'
+import { isRecord } from '../shared/is-record'
 
 /**
  * A hint that a phase's task is being worked on: `taskIndex` is the task's index in the phase's checkboxes, `at` when
- * it was seen, in milliseconds. No source writes one yet, so the heuristic of `currentTasks` decides alone.
+ * it was seen, in milliseconds. `taskSignalsOf` derives them from what the lane's agents did lately.
  */
-export type TaskSignal = { phaseId: string; taskIndex: number; at: number }
+export type TaskActivity = { phaseId: string; taskIndex: number; at: number }
 
 /** A phase as `currentTasks` reads it: its id and checkboxes. */
 export type TaskPhase = Pick<PlanPhase, 'id' | 'items'>
@@ -14,14 +16,17 @@ const isOpenTask = (phase: TaskPhase, index: number): boolean => phase.items[ind
 /** The task the newest signal younger than `staleAfterMs` points at, when it is still open; null otherwise. */
 const signalledTask = (
   phase: TaskPhase,
-  signals: readonly TaskSignal[],
+  signals: readonly TaskActivity[],
   now: number,
   staleAfterMs: number,
 ): number | null => {
   const fresh = signals
     .filter((signal) => signal.phaseId === phase.id && now - signal.at < staleAfterMs)
     .filter((signal) => isOpenTask(phase, signal.taskIndex))
-  const newest = fresh.reduce<TaskSignal | null>((last, signal) => (last && last.at >= signal.at ? last : signal), null)
+  const newest = fresh.reduce<TaskActivity | null>(
+    (last, signal) => (last && last.at >= signal.at ? last : signal),
+    null,
+  )
   return newest?.taskIndex ?? null
 }
 
@@ -38,7 +43,7 @@ const firstOpenTask = ({ items }: TaskPhase): number => {
  */
 export const currentTasks = (
   plan: readonly TaskPhase[],
-  signals: readonly TaskSignal[],
+  signals: readonly TaskActivity[],
   now: number,
   staleAfterMs: number,
 ): ReadonlyMap<string, number> =>
@@ -49,3 +54,56 @@ export const currentTasks = (
       return [[phase.id, signalledTask(phase, signals, now, staleAfterMs) ?? first] as const]
     }),
   )
+
+const WORD = /[a-zäöüß][a-zäöüß0-9-]{5,}/g
+/** The share of a task's distinctive words the agent used, from which on it counts as working on that task. */
+const SIGNAL_SHARE = 0.4
+const SIGNAL_MIN_WORDS = 3
+/** Only the start of a task's text is read: the rest is reasons and origin. */
+const TASK_TEXT_LENGTH = 200
+
+const wordsOf = (text: string): Set<string> => new Set(text.toLowerCase().match(WORD) ?? [])
+
+/**
+ * The signal each phase gets from what an agent of the lane did lately (`activity`, see `activityTextOf`): the open
+ * task of which the agent used at least `SIGNAL_SHARE` of the distinctive words (six letters or more, from the first
+ * 200 characters) and at least three, and clearly the most of all open tasks of the phase. Measured against the logs of
+ * the lane's agents: the prompt alone names several tasks, the words of the last entries single one out; the first open
+ * task stays the fallback when no task leads.
+ */
+export const taskSignalsOf = (plan: readonly TaskPhase[], activity: string, at: number): TaskActivity[] => {
+  const used = wordsOf(activity)
+  if (used.size === 0) return []
+  return plan.flatMap((phase) => {
+    const scored = phase.items.flatMap((item, taskIndex) => {
+      if (item.done) return []
+      const words = [...wordsOf(item.text.slice(0, TASK_TEXT_LENGTH))]
+      const hits = words.filter((word) => used.has(word)).length
+      return words.length > 0 && hits >= SIGNAL_MIN_WORDS && hits / words.length >= SIGNAL_SHARE
+        ? [{ taskIndex, hits }]
+        : []
+    })
+    const [best, second] = scored.sort((left, right) => right.hits - left.hits)
+    return best && best.hits > (second?.hits ?? 0) ? [{ phaseId: phase.id, taskIndex: best.taskIndex, at }] : []
+  })
+}
+
+const contentTexts = (content: unknown): string[] => {
+  if (typeof content === 'string') return [content]
+  if (!Array.isArray(content)) return []
+  return content.flatMap((block) => {
+    if (typeof block !== 'object' || block === null) return []
+    const { text, input } = block as { text?: unknown; input?: unknown }
+    return [typeof text === 'string' ? text : '', input === undefined ? '' : JSON.stringify(input)]
+  })
+}
+
+/** The text of an agent's last `entries` log entries (messages and tool inputs), for `taskSignalsOf`; lines that are no JSON are skipped. */
+export const activityTextOf = (lines: readonly string[], entries: number): string =>
+  lines
+    .slice(-entries)
+    .flatMap((line) => {
+      const message = parseLogEntry(line)?.message
+      return isRecord(message) ? contentTexts(message.content) : []
+    })
+    .join(' ')

package/src/plans/lane-standing.ts

@@ -10,7 +10,7 @@ export type LaneStanding = (typeof LANE_STANDING)[keyof typeof LANE_STANDING]
 
 type StandingInput = {
   progress: Pick<LaneProgress, 'lane' | 'done' | 'total'>
-  status: { agent: string | null; branch: string | null }
+  status: { agent: string | null; branch: string | null; dirty: number }
   pullRequests: readonly unknown[]
 }
 
@@ -45,15 +45,21 @@ const hasOpenWork = (progress: StandingInput['progress']): boolean => {
 }
 
 /**
- * Where a lane stands on the board. The cleaned-up mark goes first: it closes a lane, unless an agent, a worktree
- * or a pull request is still there, which keeps it listed. Then an agent or an open pull request makes a lane
- * active and a worktree alone lists it. Without a worktree a lane waits while it has open work, else it is closed.
+ * Where a lane stands on the board. An agent, an open pull request or uncommitted changes in its worktree make a
+ * lane active (a small fix has no agent in herdr). The cleaned-up mark goes first, but uncommitted changes in the
+ * worktree beat it: work is going on, whatever the board says. Otherwise the mark closes a lane, unless an agent, a
+ * worktree or a pull request is still there, which keeps it listed. A worktree alone lists a lane. Without a
+ * worktree a lane waits while it has open work, else it is closed.
  */
 export const laneStanding = (input: StandingInput): LaneStanding => {
   const { progress, status, pullRequests } = input
   const working = status.agent !== null || pullRequests.length > 0
-  if (progress.lane.closed) return working || status.branch !== null ? LANE_STANDING.noAgent : LANE_STANDING.closed
-  if (working) return LANE_STANDING.active
+  const editedInWorktree = status.branch !== null && status.dirty > 0
+  if (progress.lane.closed) {
+    if (editedInWorktree) return LANE_STANDING.active
+    return working || status.branch !== null ? LANE_STANDING.noAgent : LANE_STANDING.closed
+  }
+  if (working || editedInWorktree) return LANE_STANDING.active
   if (status.branch !== null) return LANE_STANDING.noAgent
   return hasOpenWork(progress) ? LANE_STANDING.waiting : LANE_STANDING.closed
 }

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[] =>