jackherd 1.7.0 → 1.8.0

package/src/watch/command.ts

@@ -5,10 +5,10 @@
  * lane's new head commit (only with `watch.previews`), a new or changed entry of a configured source or its failure (only
  * with `watch.sources`), a gh outage, a lane's or the coordinator's own context fill rising to warn or alert, or the
  * heartbeat. A blocked lane adds one duty line, a merge one per lane, a lane at alert one, and every report ends with one status line
- * per lane and one for the coordinator, in the words of `responseLanguage`. When the installed kit changes version
+ * per lane and one for the coordinator, in English. When the installed kit changes version
  * it prints `=== kit updated <old> → <new>` and ends; once a day it asks npm and prints `=== update available <old> → <new>`
  * for a newer release, once per version. The coordinator is the agent in the
- * watcher's own herdr pane unless `--coordinator` names it, else `orchestrator-<repository>`. A new start replaces a running watcher of the same
+ * watcher's own herdr pane unless `--coordinator` names it, else `jack-<repository>` (or the old `orchestrator-<repository>`). A new start replaces a running watcher of the same
  * repository; one in another repository keeps running.
  *
  * Without `--stream` it exits after one report, whose last line says so and points to the stream: that run is the
@@ -31,7 +31,7 @@ import { homedir } from 'node:os'
 import { basename, dirname, join, relative } from 'node:path'
 import { readResolvedConfig } from '../config/read-config'
 import type { JackherdConfig } from '../config/schema'
-import { defaultCoordinatorName } from '../context/coordinator-name'
+import { resolveCoordinatorName } from '../context/coordinator-name'
 import { coordinatorSettings } from '../context/options'
 import { contextReport } from '../context/report'
 import { agentLog } from '../context/session-log'
@@ -42,12 +42,19 @@ import { ensurePlanPanes } from '../plans/ensure-panes'
 import { errorText } from '../plans/error-text'
 import { mainCheckout, worktreeNames, worktreeRoot } from '../plans/git'
 import { discoverLanes, isUnchanged, laneSetChange, laneSetLines } from '../plans/lane-discovery'
-import { clockLocaleOf, type PlansSettings, plansSettingsOf, worktreeOf } from '../plans/settings'
+import { CLOCK_LOCALE, type PlansSettings, plansSettingsOf, worktreeOf } from '../plans/settings'
 import { boardTexts } from '../plans/texts'
 import { defaultUpdateCheck } from '../sync/if-changed'
 import { herdrLaneStatusSource } from '../terminal/herdr'
 import { AGENT_STATUS } from '../terminal/types'
 import { startedKit } from '../version/started-kit'
+import {
+  type AppointmentTable,
+  appointmentEvents,
+  isAppointmentEvent,
+  readAppointmentTable,
+  recordAppointments,
+} from './appointments'
 import { type ApprovalRequestFile, approvalEvents, readApprovalRequests, recordApprovals } from './approvals'
 import {
   type CoordinatorRead,
@@ -81,6 +88,7 @@ import { type LaneModelReading, laneModelEvents, recordLaneModels } from './lane
 import { laneParallelEvents, recordLaneParallels } from './lane-parallel'
 import { boardCheckoutRows, watchedLaneParallel, watchedLaneProgress } from './lane-progress'
 import {
+  appointmentEventLine,
   approvalDutyLines,
   armLine,
   blockedDutyLines,
@@ -140,7 +148,7 @@ import { runSource, SOURCE_LIMITS } from './source-run'
 import { recordWatchedSources } from './source-tickets'
 import { isSourceDue, type SourceRun, type SourceSettings, type SourceState, sourceEvents } from './sources'
 import { streamHeartbeatLine } from './stream-output'
-import { WATCH_TEXTS, type WatchTexts } from './texts'
+import { type WatchTexts, watchTexts } from './texts'
 import { updateAnnouncer } from './update-available'
 import {
   coordinatorWatchEvent,
@@ -254,6 +262,8 @@ type Watching = {
   laneParallelReadings: Record<string, string[]>
   /** 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. */
+  appointments: { table: AppointmentTable; readAt: number } | null
   planViews: PlanViews
 }
 
@@ -262,8 +272,7 @@ const GITHUB_POLL_MS = 60_000
 const MINUTE_MS = 60_000
 const USAGE_EXIT = 2
 
-const clock = (watch: Watch, epochMs: number): string =>
-  new Date(epochMs).toLocaleTimeString(clockLocaleOf(watch.settings))
+const clock = (epochMs: number): string => new Date(epochMs).toLocaleTimeString(CLOCK_LOCALE)
 
 const agentNamesOf = (agents: readonly HerdrAgent[]): string[] => agents.flatMap((agent) => agent.name ?? [])
 
@@ -292,6 +301,9 @@ const recordedOf = (watch: Watch, watching: Watching): WatchState => {
     laneParallels: recordLaneParallels(withReads.laneParallels, watching.laneParallelReadings, watching.lanes),
     approvals: watching.approvalRequests ? recordApprovals(watching.approvalRequests) : withReads.approvals,
     sources: recordWatchedSources(withReads.sources, watching.sourceRuns, watch.sources, watching.githubReadAt),
+    appointments: watching.appointments
+      ? recordAppointments(withReads.appointments, watching.appointments.table, watching.appointments.readAt)
+      : withReads.appointments,
   }
   return withReportBaselines(withLevels, watching.lanes, (lane) => reportMtime(reportPathOf(watch, lane)))
 }
@@ -337,11 +349,14 @@ const stopMessageOf = (watch: Watch, lane: string, status: string, state: WatchS
     reportedMtime: state.reportMtimes[lane] ?? null,
   })
 
-/** `--coordinator` if given, else the agent in the watcher's own pane, else `orchestrator-<repository>`. */
+/**
+ * `--coordinator` if given, else the agent in the watcher's own pane, else `jack-<repository>`, or the old
+ * `orchestrator-<repository>` while only that one runs.
+ */
 const coordinatorNameFor = (watch: Watch, agents: readonly HerdrAgent[]): string =>
   watch.options.coordinator ??
   coordinatorNameOf(agents, process.env.HERDR_PANE_ID) ??
-  defaultCoordinatorName(basename(watch.root))
+  resolveCoordinatorName(basename(watch.root), agentNamesOf(agents))
 
 /**
  * One read of the fills: the coordinator's, and each watched lane's (null without a value), with `models`, lane → the
@@ -402,6 +417,10 @@ const eventLinesOf = async (
       lines.push(...sourceEventLines(event))
       continue
     }
+    if (isAppointmentEvent(event)) {
+      lines.push(appointmentEventLine(event))
+      continue
+    }
     const headSha = event.kind === WATCH_EVENT.deploy ? runs.find((run) => run.id === event.runId)?.headSha : undefined
     const target =
       event.kind === WATCH_EVENT.deploy && headSha && watch.deploy
@@ -483,20 +502,20 @@ const statusLinesOf = async (
   const laneLines = watching.lanes.map((lane) =>
     laneReportLine(laneReportOf(lane, watching, state, pullRequests, progress[lane] ?? null), watch.texts),
   )
-  const outage = state.ghDownSince === null ? [] : [ghUnavailableStatusLine(clock(watch, state.ghDownSince))]
+  const outage = state.ghDownSince === null ? [] : [ghUnavailableStatusLine(clock(state.ghDownSince))]
   const board = { term: watch.settings.board.term, checkoutRows }
   const coordinator = coordinatorStatusLine(watching.coordinator.name, watching.coordinator.read, watch.texts, board)
   return {
     laneLines,
     coordinator,
     others: others === null ? [] : [others],
-    rest: [...notes, ...outage, ...failingSourceLines(watch, state.sources)],
+    rest: [...notes, ...outage, ...failingSourceLines(state.sources)],
   }
 }
 
-const failingSourceLines = (watch: Watch, sources: SourceState): string[] =>
+const failingSourceLines = (sources: SourceState): string[] =>
   Object.entries(sources).flatMap(([name, { failingSince }]) =>
-    failingSince === null ? [] : [sourceFailingStatusLine(name, clock(watch, failingSince))],
+    failingSince === null ? [] : [sourceFailingStatusLine(name, clock(failingSince))],
   )
 
 /** The section of each stopped lane (its header and message) and the report times it leaves behind. */
@@ -775,15 +794,31 @@ const pollGithubAndCoordinator = async (watch: Watch, watching: Watching, now: n
   ]
 }
 
-/** The board's lanes, null when the board cannot be read. */
-const readSprintLanes = (watch: Watch): SprintLane[] | null => {
+/** The board's text, null when it cannot be read; parsing it is the caller's, so a parser error is not taken for an unreadable board. */
+const readBoardText = (watch: Watch): string | null => {
   try {
-    return parseSprintLanes(readFileSync(watch.sprintFile, 'utf8'), watch.settings.planLanguage)
+    return readFileSync(watch.sprintFile, 'utf8')
   } catch {
     return null
   }
 }
 
+/**
+ * The board's appointment table at `now`, in the plan language, and when it was read; null when the board cannot be
+ * read, so the reported appointments stay as they were.
+ */
+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 }
+}
+
+/** 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)
+}
+
 /** The sprint's lane names; the previous ones when the sprint cannot be read, so no lane drops out over it. */
 const sprintLaneNames = (watch: Watch, previous: string[]): string[] =>
   readSprintLanes(watch)?.map((lane) => lane.name) ?? previous
@@ -872,7 +907,7 @@ const printStreamHeartbeat = async (watch: Watch, watching: Watching, now: numbe
   const counts = currentPhaseCountsOf(progress)
   const notes = progressNotes(watching.lanes, watching.current, counts, watching.heartbeatCounts)
   watching.heartbeatCounts = { ...watching.heartbeatCounts, ...counts }
-  console.log(streamHeartbeatLine(clock(watch, now), watching.lanes, watching.current, notes))
+  console.log(streamHeartbeatLine(clock(now), watching.lanes, watching.current, notes))
 }
 
 /**
@@ -889,7 +924,14 @@ const pollOnce = async (watch: Watch, watching: Watching): Promise<boolean> => {
   // read at every poll, not with GitHub: a lane waits for the answer only minutes; after the await, so a state saved
   // during the GitHub read records no request as seen before it was reported
   watching.approvalRequests = readApprovalRequests(watch.root)
-  const polledEvents = [...githubEvents, ...approvalEvents(watching.state.approvals, watching.approvalRequests, now)]
+  // read at every poll like the approvals; the events and the record use the same read and time, so an appointment
+  // that falls due between the two is neither recorded unreported nor reported twice
+  watching.appointments = readAppointments(watch, now)
+  const polledEvents = [
+    ...githubEvents,
+    ...approvalEvents(watching.state.approvals, watching.approvalRequests, now),
+    ...appointmentEvents(watching.state.appointments, watching.appointments?.table ?? null, now),
+  ]
   const stopped = [...firedLanes(watching.baseline, watching.current, watching.lanes), ...watching.departed]
   watching.departed = []
   const heartbeat = isHeartbeatDue(watching.quietSince, now, heartbeatMinutes * MINUTE_MS)
@@ -942,6 +984,7 @@ const initialWatching = (
   laneModelReadings: {},
   laneParallelReadings: {},
   approvalRequests: null,
+  appointments: null,
   planViews: { failureReported: false },
 })
 
@@ -1007,7 +1050,7 @@ const watchOf = (options: WatchOptions): Watch => {
     checks: config.watch.checks,
     previews: config.watch.previews,
     sources: config.watch.sources,
-    texts: WATCH_TEXTS[settings.responseLanguage],
+    texts: watchTexts(settings.responseLanguage),
     herdr: insideHerdr(settings.adapter, process.env),
   }
 }

package/src/watch/lane-report.ts

@@ -3,6 +3,7 @@ import { currentPhase, isTickedUnmerged, type LaneProgress, phasesText } from '.
 import { terminalSafe } from '../plan-format/terminal-text'
 import { CHECK_NAME_LENGTH, type ChecksState } from '../plans/pull-requests'
 import { shownWithMore } from '../plans/shown-with-more'
+import type { AppointmentEvent } from './appointments'
 import type { ApprovalEvent } from './approvals'
 import type { CoordinatorRead } from './coordinator-fill'
 import { type FeedbackEvent, firstLine } from './feedback'
@@ -74,8 +75,8 @@ const contextSegment = (level: ContextLevel | null): string[] =>
   level === null || level === CONTEXT_LEVEL.ok ? [] : [`context ${level}`]
 
 /**
- * One line per lane, in the words of `texts`: `<lane> <status> [· context warn|alert] · <branch>|kein Branch ·
- * PR #<n> <checks>|kein PR · offene Phase …|Phase … abgehakt, nicht gemergt|Plan fertig|kein Plan` in German.
+ * One line per lane, in the words of `texts`: `<lane> <status> [· context warn|alert] · <branch>|no branch ·
+ * PR #<n> <checks>|no PR · open phase …|phase … ticked, not merged|plan finished|no plan`.
  */
 export const laneReportLine = (report: LaneReport, texts: WatchTexts): string =>
   [
@@ -158,6 +159,13 @@ export const watchEventLine = (event: WatchEvent, target: string | null): string
   return `=== ${event.kind}`
 }
 
+/**
+ * The line of an appointment event: `=== due <when> · <action>` for one that fell due, `=== appointment unreadable
+ * <when> · <action>` for an open row whose time cell could not be read. Both texts come from the board as written.
+ */
+export const appointmentEventLine = (event: AppointmentEvent): string =>
+  `=== ${event.kind} ${terminalSafe(event.when)} · ${terminalSafe(event.action).slice(0, REPORT_TEXT_LENGTH)}`
+
 /**
  * The lines of a feedback event: `=== feedback #<number> (lane) <author> <label> · <k> new`, then one line per entry,
  * `<path>:<line> <first line>` or `<first line>`, cut to a length and to `FEEDBACK_ENTRY_LIMIT` entries.
@@ -230,7 +238,7 @@ const coordinatorValue = (name: string | null, read: CoordinatorRead | null, tex
 }
 
 /**
- * `coordinator <name> 62 % warn`, `coordinator <name> kein Wert (<reason>)` or `coordinator kein Name` in German;
+ * `coordinator <name> 62 % warn`, `coordinator <name> no value (<reason>)` or `coordinator no name`;
  * while the board has rows only in the checkout, `· board: 2 rows only in the checkout` follows.
  */
 export const coordinatorStatusLine = (

package/src/watch/texts.ts

@@ -1,6 +1,6 @@
-import { APPROVAL_TEXTS, PLAN_LANGUAGE, type PlanLanguage } from '../vocabulary'
+import { APPROVAL_TEXTS, type PlanLanguage } from '../vocabulary'
 
-/** The words of the watcher's status and duty lines, in the project's response language. */
+/** The words of the watcher's status and duty lines. */
 export type WatchTexts = {
   noBranch: string
   noPullRequest: string
@@ -37,60 +37,36 @@ export type WatchTexts = {
 /** The mark the approval gate hook reads from the question, as its `requestMark` writes it (contract test). */
 const approvalMark = (id: string, hash: string): string => `\`approval ${id} ${hash}\``
 
-export const WATCH_TEXTS: Record<PlanLanguage, WatchTexts> = {
-  [PLAN_LANGUAGE.de]: {
-    noBranch: 'kein Branch',
-    noPullRequest: 'kein PR',
-    openPhase: 'offene Phase',
-    tickedUnmerged: 'abgehakt, nicht gemergt',
-    phase: 'Phase',
-    startsAfter: 'Startet nach',
-    planFinished: 'Plan fertig',
-    noPlan: 'kein Plan',
-    noName: 'kein Name',
-    noValue: 'kein Wert',
-    unnamedPane: (name) => `Pane ohne Namen, herdr agent rename "$HERDR_PANE_ID" ${name}`,
-    noAgentNamed: (name) => `kein Agent namens ${name}`,
-    afterMerge: (number) => `nach Merge #${number}`,
-    mergedLaneDuty: 'nächste Phase starten oder Spur schließen',
-    otherLaneDuty: 'rebasen, dann nächste Phase starten oder Grund nennen',
-    blockedDuty:
-      'Frage gegen Plan und Regeln prüfen, in der Spur beantworten oder per Dialog an den User; nie das Pane weiterreichen',
-    laneAlertDuty: 'Übergabe an der nächsten Phasengrenze anfordern (§ 8)',
-    approvalDuty: (id, hash) =>
-      `per AskUserQuestion fragen, die Frage enthält ${approvalMark(id, hash)} (Hash wie in der gezeigten Datei), Optionen „${APPROVAL_TEXTS.de.allow}“ und „${APPROVAL_TEXTS.de.deny}“ (§ 4)`,
-    parallelDuty: (phases) =>
-      `${phases} parallel möglich: dem User vorschlagen, Inhalt und Release-Dateien selbst prüfen (Tabelle prüft nur Pfade und Marker)`,
-    laneModelDuty: 'idle umstellen: /exit, dann claude --resume <session> --model <id> im selben Pane (§ 2 Schritt 6)',
-    checkoutRows: (term, count) => `${term}: ${count} ${count === 1 ? 'Zeile' : 'Zeilen'} nur im Checkout`,
-    otherPullRequests: 'andere PRs',
-  },
-  [PLAN_LANGUAGE.en]: {
-    noBranch: 'no branch',
-    noPullRequest: 'no PR',
-    openPhase: 'open phase',
-    tickedUnmerged: 'ticked, not merged',
-    phase: 'phase',
-    startsAfter: 'starts after',
-    planFinished: 'plan finished',
-    noPlan: 'no plan',
-    noName: 'no name',
-    noValue: 'no value',
-    unnamedPane: (name) => `pane without a name, herdr agent rename "$HERDR_PANE_ID" ${name}`,
-    noAgentNamed: (name) => `no agent named ${name}`,
-    afterMerge: (number) => `after merge #${number}`,
-    mergedLaneDuty: 'start the next phase or close the lane',
-    otherLaneDuty: 'rebase, then start the next phase or name the reason to wait',
-    blockedDuty:
-      'vet the question against the plan and the rules, answer it in the lane or ask the user in a dialog; never hand the pane over',
-    laneAlertDuty: 'request the hand-over at the next phase boundary (§ 8)',
-    approvalDuty: (id, hash) =>
-      `ask through AskUserQuestion, the question contains ${approvalMark(id, hash)} (hash as in the file shown), options "${APPROVAL_TEXTS.en.allow}" and "${APPROVAL_TEXTS.en.deny}" (§ 4)`,
-    parallelDuty: (phases) =>
-      `${phases} can run in parallel: propose it to the user, check content and release files yourself (the table covers paths and markers only)`,
-    laneModelDuty:
-      'switch it while idle: /exit, then claude --resume <session> --model <id> in the same pane (§ 2 step 6)',
-    checkoutRows: (term, count) => `${term}: ${count} ${count === 1 ? 'row' : 'rows'} only in the checkout`,
-    otherPullRequests: 'other PRs',
-  },
-}
+/**
+ * The watcher's words: English whatever the project's languages. Only the two option labels in the approval duty follow
+ * `dialogLanguage` (the config's `responseLanguage`), because the coordinator asks the user with them and the approval
+ * gate hook matches the answer against exactly those labels, as `jackherd sync` renders them into it.
+ */
+export const watchTexts = (dialogLanguage: PlanLanguage): WatchTexts => ({
+  noBranch: 'no branch',
+  noPullRequest: 'no PR',
+  openPhase: 'open phase',
+  tickedUnmerged: 'ticked, not merged',
+  phase: 'phase',
+  startsAfter: 'starts after',
+  planFinished: 'plan finished',
+  noPlan: 'no plan',
+  noName: 'no name',
+  noValue: 'no value',
+  unnamedPane: (name) => `pane without a name, herdr agent rename "$HERDR_PANE_ID" ${name}`,
+  noAgentNamed: (name) => `no agent named ${name}`,
+  afterMerge: (number) => `after merge #${number}`,
+  mergedLaneDuty: 'start the next phase or close the lane',
+  otherLaneDuty: 'rebase, then start the next phase or name the reason to wait',
+  blockedDuty:
+    'vet the question against the plan and the rules, answer it in the lane or ask the user in a dialog; never hand the pane over',
+  laneAlertDuty: 'request the hand-over at the next phase boundary (§ 8)',
+  parallelDuty: (phases) =>
+    `${phases} can run in parallel: propose it to the user, check content and release files yourself (the table covers paths and markers only)`,
+  laneModelDuty:
+    'switch it while idle: /exit, then claude --resume <session> --model <id> in the same pane (§ 2 step 6)',
+  checkoutRows: (term, count) => `${term}: ${count} ${count === 1 ? 'row' : 'rows'} only in the checkout`,
+  otherPullRequests: 'other PRs',
+  approvalDuty: (id, hash) =>
+    `ask through AskUserQuestion, the question contains ${approvalMark(id, hash)} (hash as in the file shown), options "${APPROVAL_TEXTS[dialogLanguage].allow}" and "${APPROVAL_TEXTS[dialogLanguage].deny}" (§ 4)`,
+})

package/src/watch/watch-events.ts

@@ -1,4 +1,11 @@
 import { CHECKS, type ChecksState } from '../plans/pull-requests'
+import {
+  APPOINTMENT_EVENT,
+  type AppointmentEvent,
+  type AppointmentState,
+  emptyAppointmentState,
+  isAppointmentState,
+} from './appointments'
 import { APPROVAL_EVENT, type ApprovalEvent } from './approvals'
 import { type CoordinatorLevel, type CoordinatorReading, isContextLevel, levelStep } from './coordinator-fill'
 import { emptyFailureState, type FailureState, failedTestsOf, isFailureState } from './failures'
@@ -29,6 +36,8 @@ export const WATCH_EVENT = {
   laneParallel: LANE_PARALLEL_EVENT,
   approval: APPROVAL_EVENT,
   source: SOURCE_EVENT,
+  due: APPOINTMENT_EVENT.due,
+  appointmentUnreadable: APPOINTMENT_EVENT.unreadable,
 } as const
 
 export type PullRequestObservation = Omit<WatchedPullRequest, 'number' | 'branch' | 'failedRuns'>
@@ -85,6 +94,8 @@ export type WatchState = {
   reportMtimes: Record<string, number | null>
   /** The lane lines of the status block last printed; null before the first report. */
   statusLines: string[] | null
+  /** The board's appointments reported as due and its unreadable appointment rows reported, each once (`appointments.ts`). */
+  appointments: AppointmentState
 }
 
 /** The kinds of the events a pull request fires. */
@@ -130,6 +141,7 @@ export type WatchEvent =
   | LaneParallelEvent
   | ApprovalEvent
   | SourceEvent
+  | AppointmentEvent
 
 export const isPullRequestEvent = (event: WatchEvent): event is PullRequestEvent =>
   (PULL_REQUEST_KINDS as readonly string[]).includes(event.kind)
@@ -165,8 +177,12 @@ export const emptyWatchState = (): WatchState => ({
   sources: emptySourceState(),
   reportMtimes: {},
   statusLines: null,
+  appointments: emptyAppointmentState(),
 })
 
+/** The fields every state file carries since the first one; each field added later is read as empty when missing. */
+const FIRST_FORMAT_FIELDS = ['seenSeqs', 'pullRequests', 'runs', 'ghDownSince'] as const
+
 const isOneOf = (values: Record<string, string>, value: unknown): boolean =>
   typeof value === 'string' && Object.values(values).includes(value)
 
@@ -207,7 +223,8 @@ const isWatchState = (value: Record<string, unknown>): value is WatchState =>
   isSourceState(value.sources) &&
   everyValue(value.reportMtimes, isSeq) &&
   (value.statusLines === null ||
-    (Array.isArray(value.statusLines) && value.statusLines.every((line) => typeof line === 'string')))
+    (Array.isArray(value.statusLines) && value.statusLines.every((line) => typeof line === 'string'))) &&
+  isAppointmentState(value.appointments)
 
 /**
  * Reads the state file; throws on any other shape, so a damaged file is seen, not read as empty. The
@@ -217,22 +234,8 @@ export const parseWatchState = (json: string): WatchState => {
   const value: unknown = JSON.parse(json)
   if (!isRecord(value)) throw new Error('watch state: unexpected shape')
   if (isRecord(value.seenSeqs)) {
-    const complete = {
-      savedAt: null,
-      laneBranches: {},
-      coordinatorLevel: null,
-      feedback: emptyFeedbackState(),
-      failures: emptyFailureState(),
-      previews: emptyPreviewState(),
-      laneLevels: {},
-      laneModels: {},
-      laneParallels: {},
-      approvals: [],
-      sources: emptySourceState(),
-      reportMtimes: {},
-      statusLines: null,
-      ...value,
-    }
+    if (!FIRST_FORMAT_FIELDS.every((field) => field in value)) throw new Error('watch state: unexpected shape')
+    const complete = { ...emptyWatchState(), ...value }
     if (!isWatchState(complete)) throw new Error('watch state: unexpected shape')
     return complete
   }
@@ -289,23 +292,13 @@ export const recordWatchState = (previous: WatchState, observation: Observation,
     return { ...previous, seenSeqs: seenSeqsOf(lanes), ghDownSince: previous.ghDownSince ?? now, laneBranches }
   }
   return {
+    ...previous,
     seenSeqs: seenSeqsOf(lanes),
     pullRequests: recordsOf(previous, github.pullRequests, github.own ?? []),
     runs: runsOf(github.runs),
     ghDownSince: null,
     savedAt: now,
     laneBranches: keptLaneBranches(previous, observation, github.pullRequests),
-    coordinatorLevel: previous.coordinatorLevel,
-    feedback: previous.feedback,
-    failures: previous.failures,
-    previews: previous.previews,
-    laneLevels: previous.laneLevels,
-    laneModels: previous.laneModels,
-    laneParallels: previous.laneParallels,
-    approvals: previous.approvals,
-    sources: previous.sources,
-    reportMtimes: previous.reportMtimes,
-    statusLines: previous.statusLines,
   }
 }
 

package/kit/hooks/hooks/approval-gate/lane.ts

@@ -1,14 +0,0 @@
-import { isAbsolute, relative, resolve, sep } from 'node:path'
-
-/** herdr's agent names; a worktree whose directory has another name cannot be a lane. */
-const LANE_NAME = /^[a-z][a-z0-9_-]{0,31}$/
-
-export type LaneLocation = { cwd: string; main: string; worktreeDirectory: string }
-
-/** The lane whose worktree holds `cwd`: the first directory below the main checkout's worktree directory, else null. */
-export const laneOf = ({ cwd, main, worktreeDirectory }: LaneLocation): string | null => {
-  const path = relative(resolve(main, worktreeDirectory), resolve(cwd))
-  if (path === '' || path.startsWith('..') || isAbsolute(path)) return null
-  const [lane] = path.split(sep)
-  return LANE_NAME.test(lane) ? lane : null
-}