jackherd 1.24.0 → 1.26.0

package/src/vocabulary/index.ts

@@ -2,6 +2,12 @@ export const PLAN_LANGUAGE = { de: 'de', en: 'en' } as const
 
 export type PlanLanguage = (typeof PLAN_LANGUAGE)[keyof typeof PLAN_LANGUAGE]
 
+/** The languages to try when reading: `language` first, then every other known one. */
+export const languagesFrom = (language: PlanLanguage): PlanLanguage[] => [
+  language,
+  ...Object.values(PLAN_LANGUAGE).filter((other) => other !== language),
+]
+
 /** The language's name as a reply or a question says it. */
 export const LANGUAGE_NAME: Record<PlanLanguage, string> = {
   [PLAN_LANGUAGE.en]: 'English',
@@ -175,6 +181,111 @@ export const WAITING_VOCABULARY: Record<
   },
 }
 
+/**
+ * The closed set of keys a section carries in a marker, `<!-- jh: <key> -->` on the line directly under its heading.
+ * The marker names the section whatever language the heading is written in.
+ */
+export const SECTION_KEY = {
+  waiting: 'waiting',
+  appointments: 'appointments',
+  lanes: 'lanes',
+  goal: 'goal',
+  history: 'history',
+  plans: 'plans',
+  decisions: 'decisions',
+  implementation: 'implementation',
+  model: 'model',
+  dependencies: 'dependencies',
+  documentation: 'documentation',
+  forYou: 'for-you',
+  next: 'next',
+} as const
+
+export type SectionKey = (typeof SECTION_KEY)[keyof typeof SECTION_KEY]
+
+export const isSectionKey = (value: string): value is SectionKey =>
+  (Object.values(SECTION_KEY) as string[]).includes(value)
+
+/**
+ * The marker key of each line of the head section (`- **Stand:** <!-- jh: head-status --> …`). The marker names the
+ * line whatever language its label is written in.
+ */
+export const HEAD_KEY: Record<HeadLine, string> = {
+  changes: 'head-changes',
+  status: 'head-status',
+  decisions: 'head-decisions',
+  tryNow: 'head-try-now',
+  next: 'head-next',
+}
+
+/**
+ * The closed set of keys a line that opens with bold words carries in a marker
+ * (`**Kein Review-Gate** <!-- jh: no-review-gate --> reason`). The marker names the line whatever language it is in.
+ */
+export const LINE_KEY = { noReviewGate: 'no-review-gate', purpose: 'purpose' } as const
+
+/**
+ * The closed set of keys a table column carries in a marker in its header cell (`Hängt ab von <!-- jh: depends-on -->`).
+ * The marker names the column whatever language the header is written in.
+ */
+export const COLUMN_KEY = {
+  since: 'since',
+  item: 'item',
+  origin: 'origin',
+  unblocks: 'unblocks',
+  status: 'status',
+  when: 'when',
+  action: 'action',
+  dependsOn: 'depends-on',
+  writes: 'writes',
+  serialMarker: 'serial-marker',
+} as const
+
+export type ColumnKey = (typeof COLUMN_KEY)[keyof typeof COLUMN_KEY]
+
+/** The header names the column `key` goes by in `language`: its name first, then the names that count as the same column. */
+export const columnWords = (key: ColumnKey, language: PlanLanguage): readonly string[] => {
+  const waiting = WAITING_VOCABULARY[language]
+  const appointments = APPOINTMENT_VOCABULARY[language]
+  const { columns } = PLAN_VOCABULARY[language]
+  const words: Record<ColumnKey, readonly string[]> = {
+    [COLUMN_KEY.since]: [waiting.columns.since],
+    [COLUMN_KEY.item]: [waiting.columns.item],
+    [COLUMN_KEY.origin]: [waiting.columns.origin],
+    [COLUMN_KEY.unblocks]: [waiting.columns.unblocks],
+    [COLUMN_KEY.status]: [
+      waiting.columns.status,
+      ...waiting.statusAlso,
+      appointments.columns.status,
+      ...appointments.statusAlso,
+    ],
+    [COLUMN_KEY.when]: [appointments.columns.when],
+    [COLUMN_KEY.action]: [appointments.columns.action],
+    [COLUMN_KEY.dependsOn]: [columns.dependsOn],
+    [COLUMN_KEY.writes]: [columns.writes],
+    [COLUMN_KEY.serialMarker]: [columns.serialMarker],
+  }
+  return words[key]
+}
+
+/**
+ * The closed set of keys a status carries in a marker in its cell (`erledigt <!-- jh: status-done -->`): `open` for a
+ * board row that still waits, the others for the status of a plan. The marker names the status whatever language the
+ * cell is written in.
+ */
+export const STATUS_KEY = {
+  open: 'status-open',
+  done: 'status-done',
+  abandoned: 'status-abandoned',
+  inProgress: 'status-in-progress',
+  draft: 'status-draft',
+} as const
+
+export type StatusKey = (typeof STATUS_KEY)[keyof typeof STATUS_KEY]
+
+export const isStatusKey = (value: string): value is StatusKey =>
+  (Object.values(STATUS_KEY) as string[]).includes(value)
+
 export const isPlanLanguage = (value: string): value is PlanLanguage =>
   (Object.values(PLAN_LANGUAGE) as string[]).includes(value)
 
@@ -248,6 +359,8 @@ export type PlanVocabulary = {
   phase: string
   /** Opens the line by which a phase says it has no review gate on purpose: `**Kein Review-Gate:** <reason>`. */
   noReviewGate: string
+  /** Opens the line directly under a phase heading that says in one sentence what is different afterwards, for whom: `**Worum es geht:** <sentence>`. */
+  phasePurpose: string
   /** Marks a lane as closed when its name cell contains it. */
   laneClosed: string
   /** Stands in a board row's phases cell when that pull request builds only part of the phase. */
@@ -296,6 +409,7 @@ export const PLAN_VOCABULARY: Record<PlanLanguage, PlanVocabulary> = {
     columns: { dependsOn: 'Hängt ab von', writes: 'Schreibt', serialMarker: 'Seriell-Marker' },
     phase: 'Phase',
     noReviewGate: 'Kein Review-Gate',
+    phasePurpose: 'Worum es geht',
     laneClosed: 'abgeräumt',
     partialPhase: '(Teil)',
     openSubagents: 'offene Sub-Agenten',
@@ -339,6 +453,7 @@ export const PLAN_VOCABULARY: Record<PlanLanguage, PlanVocabulary> = {
     columns: { dependsOn: 'Depends on', writes: 'Writes', serialMarker: 'Serial marker' },
     phase: 'Phase',
     noReviewGate: 'No review gate',
+    phasePurpose: 'What it is about',
     laneClosed: 'cleaned up',
     partialPhase: '(part)',
     openSubagents: 'open subagents',
@@ -362,20 +477,93 @@ export const PLAN_VOCABULARY: Record<PlanLanguage, PlanVocabulary> = {
 
 const STATUS_PRECEDENCE = [PLAN_STATUS.done, PLAN_STATUS.abandoned, PLAN_STATUS.inProgress, PLAN_STATUS.draft] as const
 
-/** Classifies a free-text `Status:` line; the first matching status in precedence order wins. */
-export const classifyStatus = (language: PlanLanguage, statusText: string): PlanStatus => {
+const STATUS_OF_KEY: Partial<Record<StatusKey, PlanStatus>> = {
+  [STATUS_KEY.done]: PLAN_STATUS.done,
+  [STATUS_KEY.abandoned]: PLAN_STATUS.abandoned,
+  [STATUS_KEY.inProgress]: PLAN_STATUS.inProgress,
+  [STATUS_KEY.draft]: PLAN_STATUS.draft,
+}
+
+/** A `<!-- jh: <key> -->` marker anywhere in a text; the key is group 1. */
+export const MARKER_IN_TEXT = /<!--\s*jh:\s*([a-z-]+)\s*-->/
+
+const statusOfMarker = (statusText: string): PlanStatus | undefined => {
+  const key = MARKER_IN_TEXT.exec(statusText)?.[1]
+  return key !== undefined && isStatusKey(key) ? STATUS_OF_KEY[key] : undefined
+}
+
+const statusOfWords = (language: PlanLanguage, statusText: string): PlanStatus | undefined => {
   const { statusWords } = PLAN_VOCABULARY[language]
   const lowerStatus = statusText.toLowerCase()
   const matches = ({ leading, anywhere }: StatusWord) =>
     leading.some((word) => lowerStatus.startsWith(word)) || anywhere.some((fragment) => lowerStatus.includes(fragment))
-  const matched = STATUS_PRECEDENCE.find((status) => matches(statusWords[status]))
+  return STATUS_PRECEDENCE.find((status) => matches(statusWords[status]))
+}
+
+/**
+ * Classifies a free-text `Status:` line. A status marker (`<!-- jh: status-done -->`) decides, any language; else the
+ * first matching status in precedence order of the words of `language`, then of any other known language.
+ */
+export const classifyStatus = (language: PlanLanguage, statusText: string): PlanStatus => {
+  const marked = statusOfMarker(statusText)
+  if (marked) return marked
+  const text = statusText.replace(MARKER_IN_TEXT, '')
+  const matched = languagesFrom(language)
+    .map((candidate) => statusOfWords(candidate, text))
+    .find((status) => status !== undefined)
   if (matched) return matched
-  return statusText.trim() ? PLAN_STATUS.other : PLAN_STATUS.none
+  return text.trim() ? PLAN_STATUS.other : PLAN_STATUS.none
 }
 
 /** `### Phase 3: Title` as the plan spells it in `language`. */
 export const phaseHeading = (language: PlanLanguage, id: string, title: string): string =>
   `### ${PLAN_VOCABULARY[language].phase} ${id}: ${title}`
 
+/** The heading text of the section `key` names, as `language` writes it. */
+export const headingOfSection = (key: SectionKey, language: PlanLanguage): string => {
+  const { sections } = PLAN_VOCABULARY[language]
+  const headings: Record<SectionKey, string> = {
+    [SECTION_KEY.waiting]: WAITING_VOCABULARY[language].heading,
+    [SECTION_KEY.appointments]: APPOINTMENT_VOCABULARY[language].heading,
+    [SECTION_KEY.lanes]: sections.lanes,
+    [SECTION_KEY.goal]: sections.goal,
+    [SECTION_KEY.history]: sections.history,
+    [SECTION_KEY.plans]: sections.plans,
+    [SECTION_KEY.decisions]: sections.decisions,
+    [SECTION_KEY.implementation]: sections.implementation,
+    [SECTION_KEY.model]: sections.modelRecommendations,
+    [SECTION_KEY.dependencies]: sections.dependencies,
+    [SECTION_KEY.documentation]: sections.documentation,
+    [SECTION_KEY.forYou]: sections.forYou,
+    [SECTION_KEY.next]: NEXT_VOCABULARY[language].heading,
+  }
+  return headings[key]
+}
+
+/** The key and language of the section a heading text names, read the way a caller spells it; `null` when no language does. */
+export const sectionOfHeading = (headingText: string): { key: SectionKey; language: PlanLanguage } | null => {
+  for (const language of Object.values(PLAN_LANGUAGE)) {
+    const key = Object.values(SECTION_KEY).find((candidate) => headingOfSection(candidate, language) === headingText)
+    if (key !== undefined) return { key, language }
+  }
+  return null
+}
+
+/**
+ * The closed set of keys a lanes-table cell carries in a marker: `lane-closed` in the name cell of a lane that was
+ * cleaned up, `partial-phase` in the phases cell of a row that builds only part of a phase.
+ */
+export const CELL_KEY = { laneClosed: 'lane-closed', partialPhase: 'partial-phase' } as const
+
+export type CellKey = (typeof CELL_KEY)[keyof typeof CELL_KEY]
+
+/** The words of every known language that mark a lane as cleaned up. */
+export const LANE_CLOSED_WORDS: readonly string[] = Object.values(PLAN_VOCABULARY).map(({ laneClosed }) => laneClosed)
+
+/** The words of every known language that mark a row as building only part of a phase. */
+export const PARTIAL_PHASE_WORDS: readonly string[] = Object.values(PLAN_VOCABULARY).map(
+  ({ partialPhase }) => partialPhase,
+)
+
 export const sectionHeading = (language: PlanLanguage, section: keyof PlanVocabulary['sections']): string =>
   `## ${PLAN_VOCABULARY[language].sections[section]}`

package/src/waiting/command.ts

@@ -1,14 +1,64 @@
 import { installedReferenceHint } from '../lane/skill-hint'
+import { clockText, DAY_MS } from '../plan-format/clock'
 import { terminalSafe } from '../plan-format/terminal-text'
 import type { WaitingItem } from '../plan-format/waiting'
+import { CLOSE_REASON, closeReasonOf } from '../plans/close-reason'
 import { mainCheckout } from '../plans/git'
+import { type QuestionRecord, questionTextOf } from '../plans/question-records'
 import { closeAllQuestionRecords, closeQuestionRecords } from '../plans/questions-read'
+import { type SentFileRecord, sentTextOf } from '../plans/sent-files'
 import { closeAllSentRecords, closeSentRecords } from '../plans/sent-files-read'
-import { recordWaitingItems } from '../plans/waiting-records'
+import { readWaitingRecords, recordWaitingItems } from '../plans/waiting-records'
 import { CLI_NAME } from '../version/release'
 import { REFERENCE, referenceLine } from '../watch/reference-paths'
 
-const USAGE = `usage: ${CLI_NAME} waiting [close <id> ... | close --all]`
+const USAGE = `usage: ${CLI_NAME} waiting [--closed | close <id> ... [--reason "<text>"] | close --all [--reason "<text>"]]`
+
+const CLOSE_ALL = '--all'
+const CLOSED = '--closed'
+const REASON = '--reason'
+
+/** A closed record as `jh waiting --closed` lists it. */
+type ClosedRecord = { id: string; closedAt: number; closedReason?: string | null; text: string }
+
+const closedRecordsOf = (sent: readonly SentFileRecord[], questions: readonly QuestionRecord[]): ClosedRecord[] =>
+  [
+    ...sent.map((record) => ({ ...record, text: sentTextOf(record) })),
+    ...questions.map((record) => ({ ...record, text: questionTextOf(record) })),
+  ].flatMap(({ id, closedAt, closedReason, text }) => (closedAt === null ? [] : [{ id, closedAt, closedReason, text }]))
+
+/**
+ * The lines `jh waiting --closed` prints: the records closed within the last 24 hours, newest first, each as
+ * `id · time of closing · reason · text` (a dash for a record closed without a reason: one that predates the field, or one the hook closed itself); a note when none.
+ */
+export const closedListing = (
+  sent: readonly SentFileRecord[],
+  questions: readonly QuestionRecord[],
+  now: number,
+): string[] => {
+  const recent = closedRecordsOf(sent, questions)
+    .filter(({ closedAt }) => now - closedAt <= DAY_MS)
+    .sort((left, right) => right.closedAt - left.closedAt)
+  return recent.length === 0
+    ? ['nothing was closed in the last 24 hours']
+    : recent.map(({ id, closedAt, closedReason, text }) =>
+        terminalSafe(`${id} · ${clockText(closedAt)} · ${closedReason ?? '-'} · ${text}`),
+      )
+}
+
+/** What `jh waiting close` was asked to close and with which reason. */
+export type CloseArguments = { all: true; reason: string } | { all: false; ids: string[]; reason: string }
+
+/** The arguments after `close`: the ids or `--all`, then optionally `--reason "<text>"`; the reason is `coordinator` plus the text. Null when they do not fit. */
+export const closeArgumentsOf = (args: readonly string[]): CloseArguments | null => {
+  const at = args.indexOf(REASON)
+  if (at !== -1 && at !== args.length - 2) return null
+  const ids = at === -1 ? [...args] : args.slice(0, at)
+  const all = ids.includes(CLOSE_ALL)
+  if (ids.length === 0 || (all && ids.length > 1)) return null
+  const reason = closeReasonOf(CLOSE_REASON.coordinator, at === -1 ? '' : args[at + 1])
+  return all ? { all, reason } : { all, ids, reason }
+}
 
 /**
  * The lines `jh waiting` prints: id, time and text of each item, made safe for the terminal, then the reference that
@@ -19,41 +69,47 @@ export const waitingListing = (items: readonly WaitingItem[], hint = ''): string
     ? ['nothing waits on you']
     : [...items.map(({ since, item, id }) => terminalSafe(`${id} · ${since} · ${item}`)), ...referenceLine(hint)]
 
-const CLOSE_ALL = '--all'
-
-/** Closes the records the ids name, files and questions alike; how many it closed. */
-export const closeWaiting = (root: string, ids: readonly string[], now: number): number =>
-  closeSentRecords(root, ids, now) + closeQuestionRecords(root, ids, now)
+/** Closes the records the ids name with `reason`, files and questions alike; how many it closed. */
+export const closeWaiting = (root: string, ids: readonly string[], now: number, reason: string): number =>
+  closeSentRecords(root, ids, now, reason) + closeQuestionRecords(root, ids, now, reason)
 
-/** Closes every open record, files and questions alike; how many it closed. */
-export const closeAllWaiting = (root: string, now: number): number =>
-  closeAllSentRecords(root, now) + closeAllQuestionRecords(root, now)
+/** Closes every open record with `reason`, files and questions alike; how many it closed. */
+export const closeAllWaiting = (root: string, now: number, reason: string): number =>
+  closeAllSentRecords(root, now, reason) + closeAllQuestionRecords(root, now, reason)
 
 /**
  * `jh waiting` lists the files sent to the user and the questions left unanswered that no one closed (their id, time
- * and text); `jh waiting close <id> ...` or `close --all` closes them once the user has answered. Exit 0, 1 on a wrong
- * command line.
+ * and text); `--closed` lists what was closed in the last 24 hours with its reason; `jh waiting close <id> ...` or
+ * `close --all` closes them once the user has answered. Exit 0, 1 on a wrong command line.
  */
 export const run = async (args: string[]): Promise<number> => {
   const root = mainCheckout(process.cwd())
-  if (args.length === 0) {
-    for (const line of waitingListing(
-      recordWaitingItems(root, Date.now()),
-      installedReferenceHint(root, REFERENCE.waiting),
-    ))
-      console.log(line)
-    return 0
-  }
+  if (args.length === 0) return printWaiting(root)
+  if (args.length === 1 && args[0] === CLOSED) return printClosed(root)
   const [command, ...rest] = args
-  if (command !== 'close' || rest.length === 0) {
+  const close = command === 'close' ? closeArgumentsOf(rest) : null
+  if (close === null) {
     console.error(USAGE)
     return 1
   }
-  if (rest.includes(CLOSE_ALL) && rest.length > 1) {
-    console.error(`${CLOSE_ALL} closes everything and takes no ids\n${USAGE}`)
-    return 1
-  }
-  const closed = rest[0] === CLOSE_ALL ? closeAllWaiting(root, Date.now()) : closeWaiting(root, rest, Date.now())
+  const closed = close.all
+    ? closeAllWaiting(root, Date.now(), close.reason)
+    : closeWaiting(root, close.ids, Date.now(), close.reason)
   console.log(`closed ${closed}`)
   return 0
 }
+
+const printWaiting = (root: string): number => {
+  for (const line of waitingListing(
+    recordWaitingItems(root, Date.now()),
+    installedReferenceHint(root, REFERENCE.waiting),
+  ))
+    console.log(line)
+  return 0
+}
+
+const printClosed = (root: string): number => {
+  const { sent, questions } = readWaitingRecords(root)
+  for (const line of closedListing(sent, questions, Date.now())) console.log(line)
+  return 0
+}

package/src/watch/appointments.ts

@@ -1,7 +1,8 @@
 import { DAY_MS, twoDigits } from '../plan-format/clock'
-import { firstTableWithHeader, sectionLines } from '../plan-format/markdown'
+import { columnIndex, firstTableWithHeader, sectionLines } from '../plan-format/markdown'
+import { isOpenStatus } from '../plan-format/open-status'
 import { isRecord } from '../shared/is-record'
-import { APPOINTMENT_VOCABULARY, type PlanLanguage } from '../vocabulary'
+import { APPOINTMENT_VOCABULARY, COLUMN_KEY, type PlanLanguage } from '../vocabulary'
 
 export const APPOINTMENT_EVENT = { due: 'due', unreadable: 'appointment unreadable' } as const
 
@@ -98,22 +99,15 @@ const unreadableKey = ({ whenText, action }: UnreadableAppointment): string => `
 
 const oneLine = (text: string): string => text.replace(/\s+/g, ' ').trim()
 
-/** An empty status counts as open: a row nobody closed is not dropped in silence. */
-const isOpen = (status: string, language: PlanLanguage): boolean => {
-  const lower = status.toLowerCase()
-  return lower === '' || APPOINTMENT_VOCABULARY[language].open.some((word) => lower.startsWith(word))
-}
+const OPEN_WORDS = Object.values(APPOINTMENT_VOCABULARY).flatMap(({ open }) => open)
+
+const isOpen = (status: string): boolean => isOpenStatus(status, OPEN_WORDS)
 
 /** The row as an appointment, as an unreadable row when it is open and its time cannot be read, else as nothing. */
-const tableOfRow = (
-  cells: string[],
-  [when, action, status]: number[],
-  language: PlanLanguage,
-  now: Date,
-): AppointmentTable => {
+const tableOfRow = (cells: string[], [when, action, status]: number[], now: Date): AppointmentTable => {
   const whenText = cells[when] ?? ''
   const actionText = oneLine(cells[action] ?? '')
-  const open = isOpen(cells[status] ?? '', language)
+  const open = isOpen(cells[status] ?? '')
   const time = parseAppointmentTime(whenText, now)
   if (time)
     return {
@@ -130,19 +124,18 @@ const tableOfRow = (
  * listed as unreadable as a whole, with its header and the missing names; a section without a table has no rows.
  */
 export const readAppointmentTable = (board: string, language: PlanLanguage, now: Date): AppointmentTable => {
-  const { heading, columns, statusAlso } = APPOINTMENT_VOCABULARY[language]
+  const { heading, columns } = APPOINTMENT_VOCABULARY[language]
   const { header, rows } = firstTableWithHeader(sectionLines(board, heading))
   if (header.length === 0) return { appointments: [], unreadable: [] }
-  const statusName = [columns.status, ...statusAlso].find((name) => header.includes(name)) ?? columns.status
-  const needed = [columns.when, columns.action, statusName]
-  const missing = needed.filter((name) => !header.includes(name))
+  const needed = [COLUMN_KEY.when, COLUMN_KEY.action, COLUMN_KEY.status] as const
+  const positions = needed.map((key) => columnIndex(header, key, language))
+  const missing = needed.filter((_, index) => positions[index] === -1).map((key) => columns[key])
   if (missing.length > 0)
     return {
       appointments: [],
       unreadable: [{ whenText: header.join(' | '), action: `missing columns: ${missing.join(', ')}` }],
     }
-  const positions = needed.map((name) => header.indexOf(name))
-  const tables = rows.map((cells) => tableOfRow(cells, positions, language, now))
+  const tables = rows.map((cells) => tableOfRow(cells, positions, now))
   return {
     appointments: tables.flatMap(({ appointments }) => appointments),
     unreadable: tables.flatMap(({ unreadable }) => unreadable),

package/src/watch/command.ts

@@ -50,12 +50,15 @@ import { contextReport } from '../context/report'
 import { agentLog } from '../context/session-log'
 import { type LaneProgress, parseSprintLanes, type SprintLane } from '../plan-format'
 import { terminalSafe } from '../plan-format/terminal-text'
+import { openWaitingItems } from '../plan-format/waiting'
 import { boardFor, foundLanesOf } from '../plans/board-pick'
 import { ensurePlanPanes } from '../plans/ensure-panes'
 import { errorText } from '../plans/error-text'
 import { baseReaderOf, mainCheckout, worktreeNames, worktreeRoot } from '../plans/git'
 import { discoverLanes, isUnchanged, laneSetChange } from '../plans/lane-discovery'
 import { readerOncePerRef } from '../plans/plan-heads'
+import { readQuestionRecords } from '../plans/questions-read'
+import { closeSentRecords, readSentRecords } from '../plans/sent-files-read'
 import { CLOCK_LOCALE, type PlansSettings, plansSettingsOf, worktreeOf } from '../plans/settings'
 import { readRunningSubagents, subagentSourceOf } from '../plans/subagents-read'
 import { boardTexts } from '../plans/texts'
@@ -182,6 +185,21 @@ import {
 import { isBehindOnBase, mainCheckoutDutyLine } from './main-checkout'
 import { mergeOverlapReader } from './merge-overlap-read'
 import { monitorToolAvailable } from './monitor-tool'
+import {
+  obsoleteProposalEvents,
+  type ProposalInput,
+  type ProposalState,
+  type WaitingObsoleteEvent,
+  waitingLanesOf,
+} from './obsolete-proposals'
+import {
+  type Closing,
+  closingsByReason,
+  laneAbsenceOf,
+  obsoleteSendsOf,
+  WAITING_CLOSED_EVENT,
+  type WaitingClosedEvent,
+} from './obsolete-records'
 import { parseWatchOptions, type WatchOptions } from './options'
 import type { PlanMissingEvent, PlanMissingState } from './plan-missing'
 import { readPlanMissingEvents } from './plan-missing-read'
@@ -306,6 +324,8 @@ type Watch = {
   herdr: boolean
   /** `lanes.backend` and the worktree directory of the main checkout's config; undefined without one, then the backend is never touched. */
   backend: MainCheckoutBackend | undefined
+  /** Runs in the main checkout, not in a lane's worktree: only then does it close records of "Your turn" or propose to. */
+  inMainCheckout: boolean
 }
 
 /** The coordinator's agent name (null when none is found), its last read (null before the first one) and the tokens of that read (null without a value). */
@@ -376,6 +396,10 @@ type Watching = {
   unlinkedArtifacts: UnlinkedState
   /** Per working lane, the plan last reported as `plan missing on base`; persisted like the fingerprints. */
   planMissing: PlanMissingState
+  /** The lanes of open waiting points missing at the last heartbeat; persisted like the fingerprints. */
+  waitingMissingLanes: string[]
+  /** The reasons proposed per open waiting point as `waiting obsolete?`; persisted like the fingerprints. */
+  waitingProposals: ProposalState
   /** The approval requests of the last poll; null before the first read, so the stored ids stay. */
   approvalRequests: ApprovalRequestFile[] | null
   /** The board's appointment table at the last poll and the time it was read at; null before the first read and while the board cannot be read. */
@@ -443,6 +467,8 @@ const recordedOf = (watch: Watch, watching: Watching): WatchState => {
     laneStalls: watching.laneStalls,
     unlinkedArtifacts: watching.unlinkedArtifacts,
     planMissing: watching.planMissing,
+    waitingMissingLanes: watching.waitingMissingLanes,
+    waitingProposals: watching.waitingProposals,
     approvals: watching.approvalRequests ? recordApprovals(watching.approvalRequests) : withReads.approvals,
     ...recordedSourceState(withReads.sources, watching.sourceRuns, watching.sources.sources, watching.githubReadAt),
     appointments: watching.appointments
@@ -609,7 +635,7 @@ const boardReadOf = async (
   pullRequests: readonly WatchedPullRequest[],
 ): Promise<{ progress: Record<string, LaneProgress>; checkoutRows: number }> => {
   const text = await Bun.file(watch.sprintFile).text()
-  const sprintLanes = parseSprintLanes(text, watch.settings.planLanguage)
+  const sprintLanes = parseSprintLanes(text, watch.settings.boardLanguage)
   const watched = sprintLanes.filter((lane) => lanes.includes(lane.name))
   const planPulls = watchedPlanPullRequests(pullRequests, watch.settings)
   const headReaderOf = readerOncePerRef((ref) => baseReaderOf(watch.root, ref))
@@ -1108,13 +1134,13 @@ const readBoardText = (watch: Watch): string | null => {
 const readAppointments = (watch: Watch, now: number): Watching['appointments'] => {
   const board = readBoardText(watch)
   if (board === null) return null
-  return { table: readAppointmentTable(board, watch.settings.planLanguage, new Date(now)), readAt: now }
+  return { table: readAppointmentTable(board, watch.settings.boardLanguage, new Date(now)), readAt: now }
 }
 
 /** The line of what waits on the user's answer, from the board's own section; null when nothing is open or the board cannot be read. */
 const waitingLineOf = (watch: Watch, hint = ''): string | null => {
   return waitingLine(
-    waitingItemsOf(readBoardText(watch), watch.settings.planLanguage, readWaitingRecords(watch.root), Date.now()),
+    waitingItemsOf(readBoardText(watch), watch.settings.boardLanguage, readWaitingRecords(watch.root), Date.now()),
     hint,
   )
 }
@@ -1122,7 +1148,7 @@ const waitingLineOf = (watch: Watch, hint = ''): string | null => {
 /** The board's lanes, null when the board cannot be read. */
 const readSprintLanes = (watch: Watch): SprintLane[] | null => {
   const board = readBoardText(watch)
-  return board === null ? null : parseSprintLanes(board, watch.settings.planLanguage)
+  return board === null ? null : parseSprintLanes(board, watch.settings.boardLanguage)
 }
 
 /** The sprint's lane names; the previous ones when the sprint cannot be read, so no lane drops out over it. */
@@ -1322,6 +1348,69 @@ const unlinkedArtifactEventsOf = (watch: Watch, watching: Watching): UnlinkedArt
   }
 }
 
+/** Closes the sends through the log, one call per reason; returns the closings that were written, so a failed write is neither reported nor counted. */
+const closeObsoleteSends = (root: string, closings: readonly Closing[], now: number): Closing[] =>
+  [...closingsByReason(closings)].flatMap(([reason, ids]) => {
+    try {
+      closeSentRecords(root, ids, now, reason)
+      return ids.map((id) => ({ id, reason }))
+    } catch {
+      return []
+    }
+  })
+
+/** What the proposals read besides the records: the pull requests of the last GitHub read and the lanes' branches. */
+const proposalContextOf = (watching: Watching): Pick<ProposalInput, 'pullRequests' | 'laneBranches' | 'knownLanes'> => {
+  const laneBranches = { ...watching.state.laneBranches, ...watching.laneBranches }
+  return {
+    pullRequests: answered(watching.github)?.pullRequests ?? null,
+    laneBranches,
+    knownLanes: new Set([...Object.keys(laneBranches), ...watching.lanes]),
+  }
+}
+
+/**
+ * This heartbeat's run over "Your turn", only from the main checkout: closes the sends a safe signal makes obsolete
+ * (`waiting closed`, one event per run that closes something), then proposes what only looks obsolete (`waiting
+ * obsolete?`, each point and reason once); records the missing lanes and the proposals in `watching`. Never writes
+ * into the board. A read error closes nothing and reports nothing: the next heartbeat reads again.
+ */
+const waitingObsoleteEventsOf = (
+  watch: Watch,
+  watching: Watching,
+  now: number,
+): (WaitingClosedEvent | WaitingObsoleteEvent)[] => {
+  if (!watch.inMainCheckout) return []
+  try {
+    const worktreeDirectory = join(watch.root, watch.settings.worktreeDirectory)
+    if (!existsSync(worktreeDirectory)) return []
+    const sends = readSentRecords(watch.root)
+    const questions = readQuestionRecords(watch.root)
+    const boardText = readBoardText(watch)
+    const board = boardText === null ? null : openWaitingItems(boardText, watch.settings.boardLanguage)
+    const { missing, gone } = laneAbsenceOf(
+      waitingLanesOf({ sends, questions, board, worktreeDirectory }),
+      new Set(worktreeNames(worktreeDirectory)),
+      watching.waitingMissingLanes,
+    )
+    const closings = closeObsoleteSends(watch.root, obsoleteSendsOf(sends, worktreeDirectory, gone), now)
+    const closed = new Set(closings.map(({ id }) => id))
+    const { events, state } = obsoleteProposalEvents(watching.waitingProposals, {
+      sends: sends.filter(({ id }) => !closed.has(id)),
+      questions,
+      board,
+      worktreeDirectory,
+      gone,
+      ...proposalContextOf(watching),
+    })
+    watching.waitingMissingLanes = missing
+    watching.waitingProposals = state
+    return closings.length === 0 ? events : [{ kind: WAITING_CLOSED_EVENT, closings }, ...events]
+  } catch {
+    return []
+  }
+}
+
 /**
  * This heartbeat's `plan missing on base` events: the working lanes whose board row, as their worktree has it, links a
  * plan the base ref lacks, each once; records the state in `watching`. Nothing when the boards or git cannot be read:
@@ -1351,13 +1440,14 @@ const workingProgressOf = async (watch: Watch, watching: Watching): Promise<Reco
   return progress
 }
 
-/** The events a heartbeat of a report brings: the parallel-task proposals, the lanes without a task signal, the unlinked artifacts, the plans missing on the base. */
+/** The events a heartbeat of a report brings: the parallel-task proposals, the lanes without a task signal, the unlinked artifacts, the obsolete waiting points, the plans missing on the base. */
 const heartbeatEventsOf = async (watch: Watch, watching: Watching, now: number): Promise<WatchEvent[]> => {
   const progress = await workingProgressOf(watch, watching)
   return [
     ...taskParallelEventsOf(watch, watching, now),
     ...noTaskSignalEventsOf(watch, watching, progress, now),
     ...unlinkedArtifactEventsOf(watch, watching),
+    ...waitingObsoleteEventsOf(watch, watching, now),
     ...planMissingEventsOf(watch, watching),
   ]
 }
@@ -1421,6 +1511,7 @@ const printStreamHeartbeat = async (watch: Watch, watching: Watching, now: numbe
     ...taskParallelEventsOf(watch, watching, now),
     ...noTaskSignalEventsOf(watch, watching, progress, now),
     ...unlinkedArtifactEventsOf(watch, watching),
+    ...waitingObsoleteEventsOf(watch, watching, now),
     ...planMissingEventsOf(watch, watching),
   ]
   for (const event of events) console.log(`${watchEventLine(event, null)}${hintFor(watch, eventReference(event))}`)
@@ -1449,7 +1540,7 @@ const selfMergesOf = (watch: Watch, watching: Watching, now: number): number[] =
   const open = Object.entries(watching.state.pullRequests).flatMap(([number, { state }]) =>
     state === PULL_REQUEST_STATE.open ? [Number(number)] : [],
   )
-  return selfMergePullRequests(board, watch.settings.planLanguage, open, now, watch.selfMergeMinutes)
+  return selfMergePullRequests(board, watch.settings.boardLanguage, open, now, watch.selfMergeMinutes)
 }
 
 const clearInputOf = (
@@ -1589,6 +1680,8 @@ const initialWatching = (
   laneStalls: start.state.laneStalls,
   unlinkedArtifacts: start.state.unlinkedArtifacts,
   planMissing: start.state.planMissing,
+  waitingMissingLanes: start.state.waitingMissingLanes,
+  waitingProposals: start.state.waitingProposals,
   approvalRequests: null,
   appointments: null,
   reportQuestions: null,
@@ -1737,6 +1830,7 @@ const watchOf = (options: WatchOptions): Watch => {
     selfMergeMinutes: config.guard.selfMerge.approvalMinutes,
     herdr: insideHerdr(settings.adapter, process.env),
     backend: mainCheckoutBackendOf(root, checkoutRoot, config),
+    inMainCheckout: checkoutRoot === root,
   }
 }