jackherd 1.7.0 → 1.8.0

package/src/plans/live.ts

@@ -16,8 +16,10 @@ import {
 } from './fetch'
 import { fetchHeadPath } from './git'
 import { fetchPullRequests, noPullRequests, type PullRequestState } from './github'
+import { recallLanes, rememberLanes } from './herd-memory'
 import type { Screen } from './layout'
 import { type KnownPage, pageAfterWrite, pageKey, pageNeedsWriting, planAnchorOn, withPlanChips } from './plan-chips'
+import { herdLabel } from './plan-panes'
 import { pullRequestUrl } from './pull-requests'
 import {
   inputOutcome,
@@ -29,7 +31,7 @@ import {
   type View,
   windowTop,
 } from './selection'
-import { BASE_REMOTE, baseRefOf, boardRepoPathOf, clockLocaleOf } from './settings'
+import { BASE_REMOTE, baseRefOf, boardRepoPathOf, CLOCK_LOCALE } from './settings'
 import { singleFlight } from './single-flight'
 import { loadSnapshot, type Snapshot, type Source } from './snapshot'
 import { exportSprintPage, writeSprintPageInSteps } from './sprint-export'
@@ -51,7 +53,7 @@ type Live = {
   /** This clone's `FETCH_HEAD`, watched beside the plan files; null when git names none. */
   fetchHead: string | null
   reported: Map<string, string | null>
-  /** Per lane, the ticks seen at the last read and the phase that moved last; the herd's start empties it. */
+  /** Per lane, the ticks seen at the last read, the phase that moved last and when each moved; kept across herds (`rememberLanes`). */
   memories: Map<string, LaneMemory>
   pending: Timer | null
   /** The snapshot as read, without the plan chips; `snapshot` is this plus the chips of `page`. */
@@ -133,7 +135,7 @@ const redraw = (live: Live) => {
     live.view.selection,
     [...live.errors, ...(live.pageError ? [live.pageError] : []), ...(live.notice ? [live.notice] : [])],
     paneWidth(),
-    clockLocaleOf(live.source.settings),
+    CLOCK_LOCALE,
   )
   const top = windowTop(live.view, screen.body.cursorLine, screen.body.lines.length, bodyRows(screen))
   live.screen = screen
@@ -189,6 +191,7 @@ const refresh = (live: Live, onChange: () => void): Promise<void> => {
 const readOnce = async (live: Live, onChange: () => void) => {
   try {
     const read = await loadSnapshot(live.source, live.pullRequests, live.memories)
+    rememberLanes(live.source.root, live.memories, read.documents.laneOrder)
     const next = withKnownPage(live, read)
     live.read = read
     if (!live.snapshot) live.view = { ...live.view, selection: startSelection(next, live.source.options) }
@@ -198,7 +201,7 @@ const readOnce = async (live: Live, onChange: () => void) => {
     )
     live.view = { ...live.view, selection: folded }
     live.snapshot = next
-    const fetchLine = fetchNotice(live.fetch, baseRefOf(live.source.settings), clockLocaleOf(live.source.settings))
+    const fetchLine = fetchNotice(live.fetch, baseRefOf(live.source.settings), CLOCK_LOCALE)
     live.errors = [
       ...next.errors,
       ...(fetchLine ? [fetchLine] : []),
@@ -206,7 +209,7 @@ const readOnce = async (live: Live, onChange: () => void) => {
     ]
     syncWatchers(live.watchers, watchedFiles(next.files, live.fetchHead), onChange)
   } catch (error) {
-    const at = clockOf(clockLocaleOf(live.source.settings))
+    const at = clockOf(CLOCK_LOCALE)
     live.errors = [`refresh failed at ${at}, showing the last good state: ${errorText(error)}`]
   }
   redraw(live)
@@ -280,7 +283,7 @@ export const runLive = (source: Source): void => {
     watchers: new Map(),
     fetchHead: fetchHeadPath(source.root),
     reported: new Map(),
-    memories: new Map(),
+    memories: recallLanes(source.root),
     pending: null,
     read: null,
     page: null,
@@ -323,12 +326,14 @@ export const runLive = (source: Source): void => {
   }
   const quit = () => {
     clearTitles(source, live.reported)
+    source.terminal.labelOwnPane(null)
     for (const watcher of live.watchers.values()) watcher.close()
     process.stdout.write(TERMINAL_OFF)
     process.exit(0)
   }
   const onInput = (input: string) => (QUIT_KEYS.has(input) ? quit() : handleInput(live, input))
 
+  source.terminal.labelOwnPane(herdLabel(source.options.lane))
   enterTerminal(onInput, quit, () => redraw(live))
   setInterval(() => {
     fetchWhenDue(false)

package/src/plans/plan-panes.ts

@@ -135,6 +135,21 @@ const quoted = (arg: string): string => (/^[\w@%+=:,./-]+$/.test(arg) ? arg : `'
 export const viewCommandOf = (argv: readonly string[], lane: string | null): string =>
   [...argv.slice(0, 2), HERD_COMMAND.name, ...(lane ? ['--lane', lane] : [])].map(quoted).join(' ')
 
+/** The pane label of a herd: `herd` for every lane, `herd · <lane>` for one lane. */
+export const herdLabel = (lane: string | null): string => (lane ? `${HERD_COMMAND.name} · ${lane}` : HERD_COMMAND.name)
+
+/** The pane label of the coordinator. */
+export const COORDINATOR_LABEL = '🐾 Jack'
+
+/** The coordinator's pane with its label, null when there is no coordinator pane among `panes`. */
+export const coordinatorLabelOf = (
+  panes: readonly PaneState[],
+  coordinator: string | null,
+): { pane: string; label: string } | null =>
+  coordinator && panes.some((each) => each.pane === coordinator)
+    ? { pane: coordinator, label: COORDINATOR_LABEL }
+    : null
+
 /** The new pane of a `herdr pane split` answer; throws on a changed answer. */
 export const splitPaneOf = (json: string): string => {
   const pane = (JSON.parse(json) as { result?: { pane?: { pane_id?: unknown } } }).result?.pane?.pane_id

package/src/plans/planned.ts

@@ -1,8 +1,9 @@
 import { posix } from 'node:path'
 import {
-  PHASE_ID_PREFIX,
+  isPhaseOpen,
   type PlanPhase,
   parsePlanPhases,
+  phaseLabels,
   readPlanHeader,
   resolvePlanPath,
   type SprintLane,
@@ -31,16 +32,10 @@ export type PlannedInput = {
   language: PlanLanguage
 }
 
-/**
- * A phase is open while a task before its review gate is unticked; an open documentation or roadmap box in
- * the gate does not reopen a phase that is built and merged. A phase that has only gate boxes counts by them.
- */
-const isOpen = ({ items }: PlanPhase): boolean => {
-  const tasks = items.filter(({ gate }) => !gate)
-  return (tasks.length > 0 ? tasks : items).some(({ done }) => !done)
-}
+/** A plan's file, its text and its phases, as one plan row reads them. */
+type PlanRead = { path: string; markdown: string; phases: readonly PlanPhase[] }
 
-const openPhases = (phases: PlanPhase[]): PlanPhase[] => phases.filter(isOpen)
+const openPhases = (phases: readonly PlanPhase[]): PlanPhase[] => phases.filter(isPhaseOpen)
 
 const isRunning = ({ lane, agent }: PlannedLane): boolean => agent !== null && !lane.closed
 
@@ -51,8 +46,8 @@ const planPaths = ({ lane }: PlannedLane, sprintDirectory: string): string[] =>
 const followedPaths = ({ lanes, sprintDirectory }: PlannedInput): Set<string> =>
   new Set(lanes.filter(isRunning).flatMap((lane) => planPaths(lane, sprintDirectory)))
 
-const plannedPlanOf = (path: string, markdown: string, language: PlanLanguage, excluded: ReadonlySet<string>) => {
-  const phases = openPhases(parsePlanPhases(markdown, language)).filter(({ id }) => !excluded.has(id))
+const plannedPlanOf = ({ path, markdown, phases: all }: PlanRead, language: PlanLanguage) => {
+  const phases = openPhases(all)
   if (phases.length === 0) return []
   const items = phases.flatMap((phase) => phase.items)
   const plan: PlannedPlan = {
@@ -77,40 +72,12 @@ export const plannedPlans = (input: PlannedInput): PlannedPlan[] => {
     const path = resolvePlanPath(input.sprintDirectory, href)
     if (seen.has(path) || followed.has(path)) return []
     seen.add(path)
-    return plannedPlanOf(path, markdown, input.language, new Set())
+    return plannedPlanOf({ path, markdown, phases: parsePlanPhases(markdown, input.language) }, input.language)
   })
 }
 
-/**
- * The open phases of the plans a lane works on that its own steps do not name, which is what comes after the
- * phase the lane is on. Empty for a lane without an agent or a closed one: it is listed in the closing block.
- */
-export const followingPlans = (planned: PlannedLane, input: Omit<PlannedInput, 'lanes'>): PlannedPlan[] => {
-  if (!isRunning(planned)) return []
-  const seen = new Set<string>()
-  return planned.lane.steps.flatMap(({ planHref }) => {
-    const markdown = planHref ? input.plans[planHref] : undefined
-    const path = planHref ? resolvePlanPath(input.sprintDirectory, planHref) : null
-    if (path === null || markdown === undefined || seen.has(path)) return []
-    seen.add(path)
-    const named = new Set(
-      planned.lane.steps
-        .filter((step) => step.planHref !== null && resolvePlanPath(input.sprintDirectory, step.planHref) === path)
-        .flatMap((step) => step.phaseIds),
-    )
-    return plannedPlanOf(path, markdown, input.language, named)
-  })
-}
-
-/** The plan the lane's current phase belongs to goes first; the others keep their order. */
-export const currentPlanFirst = (plans: readonly PlannedPlan[], currentPath: string | null): PlannedPlan[] => [
-  ...plans.filter(({ path }) => path === currentPath),
-  ...plans.filter(({ path }) => path !== currentPath),
-]
-
 /** `P3 P4 P5` */
-export const phaseList = (plan: Pick<PlannedPlan, 'phaseIds'>): string =>
-  plan.phaseIds.map((id) => `${PHASE_ID_PREFIX}${id}`).join(' ')
+export const phaseList = (plan: Pick<PlannedPlan, 'phaseIds'>): string => phaseLabels(plan.phaseIds, ' ')
 
 /** How many phases the plans list together. */
 export const plannedPhaseCount = (planned: readonly Pick<PlannedPlan, 'phaseIds'>[]): number =>

package/src/plans/selection.ts

@@ -36,8 +36,8 @@ export type InputContext = {
   bodyRows: number
 }
 
-/** A clickable span of a frame line, columns 0-based and `to` exclusive. */
-export type ClickTarget = { line: number; from: number; to: number; key: string }
+/** A clickable span of a frame line, columns 0-based and `to` exclusive; `wholeLine` spans the pane whatever leads it. */
+export type ClickTarget = { line: number; from: number; to: number; key: string; wholeLine?: true }
 
 /** An SGR mouse report; column and row are 1-based as the terminal sends them. */
 export type MouseEvent = { button: number; column: number; row: number; pressed: boolean }
@@ -71,12 +71,8 @@ export const PLANNED_KEY = 'planned'
 
 export const phaseKey = (lane: string, stepIndex: number, phaseId: string): string => `${lane}:${stepIndex}:${phaseId}`
 
-const FOLLOWING_KEY_PREFIX = 'following>'
 const TICKED_KEY_PREFIX = 'ticked>'
 
-/** The key of the folded row under a lane that lists the open phases after its own. */
-export const followingKey = (lane: string): string => `${FOLLOWING_KEY_PREFIX}${lane}`
-
 /** The key of the "N ticked" line of an open phase; it is clicked only, and a click lands on the phase. */
 export const tickedKey = (phase: string): string => `${TICKED_KEY_PREFIX}${phase}`
 

package/src/plans/settings.ts

@@ -3,7 +3,6 @@ import { join, relative } from 'node:path'
 import { type JackherdConfig, parseJackherdConfig } from '../config'
 import { PROJECT_CONFIG_PATH } from '../config/location'
 import { readConfig } from '../config/read-config'
-import { PLAN_LANGUAGE, type PlanLanguage } from '../vocabulary'
 import type { TicketSource } from '../watch/plan-badges'
 
 export const CONFIG_PATH = PROJECT_CONFIG_PATH
@@ -20,10 +19,8 @@ export type PlansSettings = Pick<
   ticketSources: TicketSource[]
 }
 
-const CLOCK_LOCALE: Record<PlanLanguage, string> = {
-  [PLAN_LANGUAGE.de]: 'de-DE',
-  [PLAN_LANGUAGE.en]: 'en-GB',
-}
+/** The locale of the herd's clock: the herd is English, with a 24-hour clock. */
+export const CLOCK_LOCALE = 'en-GB'
 
 /** The herd's slice of a validated config. */
 export const plansSettingsOf = (config: JackherdConfig): PlansSettings => ({
@@ -67,8 +64,6 @@ export const BASE_REMOTE = 'origin'
 
 export const baseRefOf = ({ baseBranch }: Pick<PlansSettings, 'baseBranch'>): string => `${BASE_REMOTE}/${baseBranch}`
 
-export const clockLocaleOf = (settings: PlansSettings): string => CLOCK_LOCALE[settings.responseLanguage]
-
 /** The herd's settings from the config `readConfig` finds. */
 export const readSettings = (roots: string[], home: string = homedir()): PlansSettings =>
   plansSettingsOf(readConfig(roots, home))

package/src/plans/snapshot.ts

@@ -14,22 +14,30 @@ import {
   sprintTitleOf,
 } from '../plan-format'
 import type { LaneAgent, LaneStatusSource } from '../terminal'
-import type { PlanLanguage } from '../vocabulary'
 import type { SourceTicket, WatchBadges, WatchHealth } from '../watch/plan-badges'
 import { readWatchReading } from '../watch/plan-badges-read'
 import { boardRowsOf } from './board-rows'
-import { type LaneMemory, newestRowIdentity, nextMemory, withMovedPhase } from './current-phase'
+import {
+  type ActivityTimes,
+  type LaneMemory,
+  newestRowIdentity,
+  nextActivity,
+  nextMemory,
+  type PlanModified,
+  withMovedPhase,
+} from './current-phase'
 import { errorText } from './error-text'
 import { type BaseReader, baseReaderOf, gitStatusOf, refExists } from './git'
 import type { PullRequestState } from './github'
 import { type Fallbacks, laneWorkOf, readAtBase, readFallback, readPlans, textAtBase } from './lane-plans'
+import { laneSummary } from './lane-summary'
 import { boardRowTexts, laneTicketsOf, withoutTicketLinks } from './lane-tickets'
 import { type LaneView, sortByUrgency } from './layout'
 import { extractLinkChips } from './link-chips'
 import type { Options } from './options'
 import { laneModelsOf, type PhaseModelRecord } from './phase-models'
 import { readPhaseModels } from './phase-models-read'
-import { currentPlanFirst, followingPlans, type PlannedPlan, plannedPlans } from './planned'
+import { type PlannedPlan, plannedPlans } from './planned'
 import { baseRefOf, boardRepoPathOf, type PlansSettings, worktreeOf } from './settings'
 import { boardTexts } from './texts'
 import { type UnlistedLane, unlistedLanes, unlistedSprintLane } from './unlisted-lanes'
@@ -44,8 +52,6 @@ export type Source = {
   terminal: LaneStatusSource
   /** The log lines of an agent's chat, null without one; defaults to reading them from `~/.claude/projects`. */
   readAgentLog?: AgentLogReader
-  /** Why this board was chosen over others, shown with the errors; null or absent when there was no choice. */
-  boardNotice?: string | null
 }
 
 /**
@@ -80,8 +86,6 @@ export type Snapshot = {
   watch?: WatchHealth
   /** True when the config marks a ticket source, so a missing watcher is said without a pull request too. */
   watchesTickets?: boolean
-  /** The project's response language, for the words of the watcher's badges. */
-  language?: PlanLanguage
 }
 
 type LaneSources = {
@@ -104,12 +108,6 @@ const contextOf = (agent: LaneAgent | undefined, source: Source): ContextReading
   return report && { share: report.share, level: report.level }
 }
 
-/** The repository path of the plan the lane's current phase belongs to; null when every phase is done. */
-const currentPlanPath = ({ current, steps }: LaneProgress, sprintDirectory: string): string | null => {
-  const href = current ? steps[current.stepIndex].step.planHref : null
-  return href ? resolvePlanPath(sprintDirectory, href) : null
-}
-
 /** What a lane's worktree and agent say, listed in the sprint or not: git state, pull requests, context. */
 const runningState = async (sources: LaneSources, name: string, agent: LaneAgent | undefined) => {
   const { source, pullRequests } = sources
@@ -118,6 +116,7 @@ const runningState = async (sources: LaneSources, name: string, agent: LaneAgent
     gitStatus,
     view: {
       status: { agent: agent?.status ?? null, ...gitStatus },
+      ...(agent?.title ? { sessionTitle: agent.title } : {}),
       pullRequests: gitStatus.branch ? (pullRequests.byBranch.get(gitStatus.branch) ?? []) : [],
       context: contextOf(agent, source),
     },
@@ -125,25 +124,31 @@ const runningState = async (sources: LaneSources, name: string, agent: LaneAgent
 }
 
 /**
- * The progress of a lane with the phase whose boxes moved since the last read as its current one: the lane's memory
- * in `memories` is updated by this read. Without `memories` the newest board row decides alone.
+ * The progress of a lane with the phase whose boxes moved since the last read as its current one, and when each of
+ * its phases last moved, a movement bounded by when its plan file was last written (`modified`): the lane's memory in
+ * `memories` is updated by this read at `now`. Without `memories` the newest board row decides alone and no movement
+ * is known.
  */
 const progressWithMemory = (
   shown: SprintLane,
   plans: PlansByHref,
   memories: Map<string, LaneMemory> | undefined,
-): LaneProgress => {
+  { now, modified }: { now: number; modified: PlanModified },
+): { progress: LaneProgress; activity: ActivityTimes } => {
   const progress = laneProgress(shown, plans)
-  if (!memories) return progress
-  const memory = nextMemory(memories.get(shown.name), plans, newestRowIdentity(progress))
-  memories.set(shown.name, memory)
-  return withMovedPhase(progress, memory.moved)
+  if (!memories) return { progress, activity: {} }
+  const previous = memories.get(shown.name)
+  const memory = nextMemory(previous, plans, newestRowIdentity(progress))
+  const activity = nextActivity(previous, memory.ticks, now, modified)
+  memories.set(shown.name, { ...memory, activity })
+  return { progress: withMovedPhase(progress, memory.moved), activity }
 }
 
 const laneView = async (
   sources: LaneSources,
   lane: SprintLane,
   fallbacks: Fallbacks,
+  now: number,
   memories?: Map<string, LaneMemory>,
 ): Promise<LaneResult> => {
   const { source, agents } = sources
@@ -151,27 +156,26 @@ const laneView = async (
   const worktree = worktreeOf(root, settings, lane.name)
   const agent = agents.find((candidate) => candidate.name === lane.name)
   const { gitStatus, view: running } = await runningState(sources, lane.name, agent)
-  const { plans, files, texts } = await readPlans(
+  const {
+    plans: phasesByHref,
+    files,
+    texts,
+    modified,
+  } = await readPlans(
     lane,
     { root, settings, base: sources.base, sprintDirectory: sources.sprintDirectory },
     laneWorkOf(worktree, gitStatus),
     fallbacks,
   )
-  const shown = withWorkedPhases(lane, plans)
-  const progress = progressWithMemory(shown, plans, memories)
+  const shown = withWorkedPhases(lane, phasesByHref)
+  const { progress, activity } = progressWithMemory(shown, phasesByHref, memories, { now, modified })
   const view: LaneView = {
     progress,
     ...running,
     chips: Object.fromEntries(
       Object.entries(texts).map(([href, text]) => [href, extractLinkChips(text, settings.linkKinds)]),
     ),
-    following: currentPlanFirst(
-      followingPlans(
-        { lane: shown, agent: agent?.status ?? null },
-        { plans: texts, sprintDirectory: sources.sprintDirectory, language: settings.planLanguage },
-      ),
-      currentPlanPath(progress, sources.sprintDirectory),
-    ),
+    summary: laneSummary({ progress, phases: phasesByHref, texts, activity, language: settings.planLanguage }, now),
   }
   return { view, files, texts, pane: agent?.pane ?? null }
 }
@@ -318,8 +322,9 @@ export const loadSnapshot = async (
     agents,
     pullRequests,
   }
+  const now = Date.now()
   const results = [
-    ...(await Promise.all(lanes.map((lane) => laneView(sources, lane, fallbacks, memories)))),
+    ...(await Promise.all(lanes.map((lane) => laneView(sources, lane, fallbacks, now, memories)))),
     ...(await Promise.all(unlisted.map((lane) => unlistedView(sources, lane)))),
   ]
   forgetLanes(memories, lanes)
@@ -335,7 +340,7 @@ export const loadSnapshot = async (
       })
   const { ticketSources } = settings
   const watched = ticketSources.length > 0 || results.some(({ view }) => view.pullRequests.length > 0)
-  const reading = watched ? readWatchReading(root, Date.now(), ticketSources) : null
+  const reading = watched ? readWatchReading(root, now, ticketSources) : null
   const phaseModels = readPhaseModels(root)
   const baseRef = baseRefOf(settings)
   const notice = fallbacks.length > 0 ? fallbackNotice(fallbacks, baseRef, refExists(root, baseRef)) : null
@@ -361,14 +366,8 @@ export const loadSnapshot = async (
     planned,
     files: [sprintFile, ...results.flatMap((result) => result.files)],
     titles: new Map(results.flatMap(({ view, pane }) => (pane ? [[pane, shortTitle(view.progress)]] : []))),
-    errors: [
-      ...errors,
-      ...pullRequests.errors,
-      ...(notice ? [notice] : []),
-      ...(source.boardNotice ? [source.boardNotice] : []),
-    ],
+    errors: [...errors, ...pullRequests.errors, ...(notice ? [notice] : [])],
     watch: reading?.health,
     ...(ticketSources.length > 0 ? { watchesTickets: true } : {}),
-    language: settings.responseLanguage,
   }
 }

package/src/plans/symbols.ts

@@ -45,8 +45,8 @@ export const phaseStateOf = ({
 /** What a phase shows in place of a symbol: `0/5`, `✓ 15/15`, `–` without checkboxes, `?` when the plan lacks it. */
 export const PHASE_COUNT = { missing: '?', empty: '–', allTicked: '✓' } as const
 
-/** Beside the model a phase's subagent ran on: it fits the plan's recommendation, or it differs from it. */
-export const MODEL_MARK = { fits: '✓', differs: '≠' } as const
+/** Between the model a phase's subagent ran on and the plan's recommendation it differs from. */
+export const MODEL_MARK = { differs: '≠' } as const
 
 export const phaseCountOf = (phase: { title: string | null; done: number; total: number }): string => {
   const state = phaseStateOf(phase)

package/src/plans/texts.ts

@@ -1,11 +1,20 @@
-import { PLAN_LANGUAGE, type PlanLanguage } from '../vocabulary'
+import { STALE_ACTIVITY_MINUTES } from './lane-summary'
 import { CHECK_NAME_LENGTH, CHECKS, type ChecksState, type PullRequest } from './pull-requests'
 import { shownWithMore } from './shown-with-more'
 import { MODEL_MARK, NO_AGENT_WORD, PHASE_COUNT } from './symbols'
 
+/** The words of an open lane: its section labels, the age of a running phase, the wave, the finished phases not merged yet, and the pointer of a phase with only its review gate open. */
+export type HerdTexts = {
+  sections: { session: string; chips: string; now: string; next: string; later: string; done: string }
+  minutesAgo: (minutes: number) => string
+  wave: (wave: number) => string
+  notMerged: string
+  reviewGate: string
+}
+
 /**
- * Everything the herd says in words but the watcher's badges. The herd is English whatever language the
- * project answers in; plan and phase titles come from the plans as written, and the status words are herdr's own terms.
+ * Everything the herd says in words but the watcher's badges. The herd is English whatever language the project
+ * answers in; plan and phase titles and tasks come from the plans as written, and the status words are herdr's own terms.
  */
 export type PlanTexts = {
   noAgent: string
@@ -15,24 +24,20 @@ export type PlanTexts = {
   noWorktree: string
   noRow: string
   notInPlan: string
-  noCheckboxes: string
   /** In place of the count of a phase whose only open box is the documentation box of its review gate. */
   allButDocs: string
-  tickedUnmerged: string
   tickedSummary: (count: number) => string
   draft: string
   privateLink: string
   planned: (phases: number, plans: number) => string
-  following: (groups: string) => string
+  phaseTally: (done: number, total: number) => string
+  herd: HerdTexts
   checks: Record<ChecksState, string>
   hint: string
   legend: string[]
 }
 
-/**
- * The words of the watcher's badges and of the header notice when they are missing, in the project's response
- * language (D96): they report on the lane's pull request as the watcher's own messages do.
- */
+/** The words of the watcher's badges and of the header notice when they are missing. */
 export type BadgeTexts = {
   preview: string
   /** The feedback since the last push, without ignored authors. */
@@ -42,21 +47,12 @@ export type BadgeTexts = {
   stale: (minutes: number) => string
 }
 
-export const BADGE_TEXTS: Record<PlanLanguage, BadgeTexts> = {
-  [PLAN_LANGUAGE.de]: {
-    preview: '🌐 preview',
-    feedback: (count) => `💬 ${count} neu`,
-    changesRequested: '✋ Änderungen verlangt',
-    watcherOff: 'Watcher aus',
-    stale: (minutes) => `Stand ${minutes} min alt`,
-  },
-  [PLAN_LANGUAGE.en]: {
-    preview: '🌐 preview',
-    feedback: (count) => `💬 ${count} new`,
-    changesRequested: '✋ changes requested',
-    watcherOff: 'watcher off',
-    stale: (minutes) => `state ${minutes} min old`,
-  },
+export const BADGE_TEXTS: BadgeTexts = {
+  preview: '🌐 preview',
+  feedback: (count) => `💬 ${count} new`,
+  changesRequested: '✋ changes requested',
+  watcherOff: 'watcher off',
+  stale: (minutes) => `state ${minutes} min old`,
 }
 
 /** What the herd says about a board, in the word the project calls it (`board.term`). */
@@ -80,13 +76,18 @@ export const TEXTS: PlanTexts = {
   noWorktree: 'no worktree',
   noRow: 'no row in lanes',
   notInPlan: 'not in the plan',
-  noCheckboxes: 'no checkboxes',
   allButDocs: ALL_BUT_DOCS,
-  tickedUnmerged: 'ticked, not merged',
   tickedSummary: (count) => `${count} ticked · click or a lists them`,
   draft: 'draft · ',
   privateLink: 'private',
-  following: (groups) => `also open · ${groups}`,
+  phaseTally: (done, total) => (total > 0 ? `${done}/${total} ph` : ''),
+  herd: {
+    sections: { session: 'SESSION', chips: '📎', now: 'NOW', next: 'NEXT', later: 'LATER', done: 'DONE' },
+    minutesAgo: (minutes) => (minutes === 0 ? '· just now' : `· ${minutes} min ago`),
+    wave: (wave) => `wave ${wave}:`,
+    notMerged: 'not merged',
+    reviewGate: 'Review gate',
+  },
   planned: (phases, plans) =>
     `planned (${phases} ${phases === 1 ? 'phase' : 'phases'} in ${plans} ${plans === 1 ? 'plan' : 'plans'})`,
   checks: {
@@ -99,10 +100,10 @@ export const TEXTS: PlanTexts = {
   legend: [
     'enter/space or click toggles a lane or a phase, click or enter on a task opens its whole text, and opens a ↗ pull request · wheel PgUp PgDn scroll · j k h l like the arrows · click or ctrl+click on a 📎 chip opens its link · ✦ artifact · ⑂ pull request or issue · ◈ Figma · private = the plan says so',
     '● working · ◆ blocked, waits for you · ◉ done = the agent finished its answer, not the lane · ○ idle · (·) no agent = a worktree nobody works in · waiting = not started: no worktree yet, something left to do, and what it starts after; finished lanes (cleaned up, or every named phase ticked) are not shown · working and blocked lanes open by themselves, → ← overrule until the status changes',
-    `▸ ▾ open and close · ▶ next open task · ✓ finished phase · ${ALL_BUT_DOCS} = only the documentation box is open · ticked, not merged = all ticked in the worktree, not on the base branch yet · the herd follows the phase whose boxes moved last, in yellow · ${PHASE_COUNT.empty} no checkboxes · ${PHASE_COUNT.missing} not in the plan · a lists the ticked checkboxes one by one · s opens every lane and plan as one HTML page`,
-    `◐ lane progress · n/m = m checkboxes of the phase, n ticked · n/n in green = all ticked · 🥣 share of the context window used · Opus ${MODEL_MARK.fits} = the phase's subagent ran on the plan's model, Sonnet ${MODEL_MARK.differs} Opus in amber = on another`,
+    `▸ ▾ open and close · NOW ▶ the phases whose boxes or task lines moved in the last ${STALE_ACTIVITY_MINUTES} min, the one moved last first, · n min ago since then, → the task each is on (Review gate = only its review gate is open) · NEXT the next wave · LATER the other open phases · DONE ✓ the finished ones, not merged = ticked in the worktree, not on the base branch yet · ${ALL_BUT_DOCS} = only the documentation box is open · the lane line names the phase moved last · ${PHASE_COUNT.empty} no checkboxes · ${PHASE_COUNT.missing} not in the plan · a lists the ticked checkboxes one by one · s opens every lane and plan as one HTML page`,
+    `◐ progress over the lane's plans · n/m = m checkboxes, n ticked · n/m ph = n of m phases finished · n/n in green = all ticked · 🥣 share of the context window used · Sonnet ${MODEL_MARK.differs} Opus in amber = the phase's subagent ran on another model than the plan's`,
     '↗ pull request · 💬 new feedback · ✋ changes requested · 🌐 preview · 📡 ticket: chip 📡 T-1 · status under 📎, 📡 <n> in amber on a folded lane when tickets are new',
-    '⎇ branch · ↑ commits ahead · ± uncommitted · no worktree: plan read from main',
+    "SESSION: the agent's title · ⎇ branch · ↑ commits ahead · ± uncommitted · no worktree: plan read from main",
   ],
 }
 

package/src/plans/view.ts

@@ -37,7 +37,6 @@ export const renderSnapshot = (
       planned: snapshot.planned,
       watch: snapshot.watch,
       watchesTickets: snapshot.watchesTickets,
-      language: snapshot.language,
     },
     selection,
     width,

package/src/plans/worked-phases.ts

@@ -1,9 +1,9 @@
 import {
   type LaneProgress,
   laneProgress,
-  PHASE_ID_PREFIX,
   type PlanStep,
   type PlansByHref,
+  phaseLabels,
   type SprintLane,
 } from '../plan-format'
 import { belongsToLane } from './phase-source'
@@ -24,7 +24,7 @@ const workedStep = (last: PlanStep, ids: string[]): PlanStep => ({
   planTitle: last.planTitle,
   planHref: last.planHref,
   phaseIds: ids,
-  label: ids.map((id) => `${PHASE_ID_PREFIX}${id}`).join(' '),
+  label: phaseLabels(ids, ' '),
   startsAfter: '',
   model: '',
   withoutRow: true,