jackherd 1.8.1 → 1.10.0

package/src/plans/current-phase.ts

@@ -6,7 +6,7 @@ export type PhaseRef = { planHref: string; phaseId: string }
 /** Per plan link and phase id, the state of its checkboxes as `1` (ticked) and `0` (open) in plan order. */
 export type TickSnapshot = Record<string, Record<string, string>>
 
-/** When a phase's ticks or task lines last moved, in milliseconds, by `activityKey`. */
+/** When a phase was last ticked or unticked, in milliseconds, by `activityKey`. */
 export type ActivityTimes = Readonly<Record<string, number>>
 
 /**
@@ -54,20 +54,30 @@ export const movedPhases = (previous: TickSnapshot, next: TickSnapshot): PhaseRe
     }),
   )
 
-/** The phases `next` has in a plan `previous` read already but without them: task lines a lane wrote into a new phase. */
-const addedPhases = (previous: TickSnapshot, next: TickSnapshot): PhaseRef[] =>
+const tickCount = (ticks: string): number => [...ticks].filter((state) => state === '1').length
+
+/**
+ * The phases whose number of ticks changed between two reads of a plan `previous` read already, a phase new in `next`
+ * counted from none: a tick is activity, task lines written into a phase are not, so phases a lane only wrote down
+ * never run (17:10). A phase remembered in the format before D67 has no state to move from.
+ */
+const tickedPhases = (previous: TickSnapshot, next: TickSnapshot): PhaseRef[] =>
   Object.entries(next).flatMap(([planHref, phases]) => {
     const before = previous[planHref]
     if (before === undefined) return []
-    return Object.keys(phases).flatMap((phaseId) => (phaseId in before ? [] : [{ planHref, phaseId }]))
+    return Object.entries(phases).flatMap(([phaseId, ticks]) => {
+      const old = before[phaseId]
+      if (old !== undefined && !old.startsWith(TASK_TICKS)) return []
+      return tickCount(old ?? '') === tickCount(ticks) ? [] : [{ planHref, phaseId }]
+    })
   })
 
 /** When each plan file was last written, in milliseconds, by plan link; a plan without an entry is bounded by the clock. */
 export type PlanModified = Readonly<Record<string, number>>
 
 /**
- * When each phase last moved, after a read at `now` whose ticks are `ticks`: a phase whose ticks or task lines changed
- * since `previous`, or that is new in a plan `previous` read already, takes the time its plan file was last written
+ * When each phase was last ticked, after a read at `now` whose ticks are `ticks`: a phase whose number of ticks changed
+ * since `previous` (`tickedPhases`), a new one in a plan `previous` read already included, takes the time its plan file was last written
  * (`modified`), bounded by `now`, so a change first seen long after it was made is not taken for a fresh one; the
  * others keep their time. The first read knows no movement, so without a remembered read no phase has a time.
  */
@@ -78,7 +88,7 @@ export const nextActivity = (
   modified: PlanModified = {},
 ): ActivityTimes => {
   if (!previous) return {}
-  const changed = [...movedPhases(previous.ticks, ticks), ...addedPhases(previous.ticks, ticks)]
+  const changed = tickedPhases(previous.ticks, ticks)
   return {
     ...previous.activity,
     ...Object.fromEntries(

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/fetch.ts

@@ -1,5 +1,7 @@
 import { errorText } from './error-text'
 import type { PullRequestState } from './github'
+import { pullHeadRefspec } from './plan-heads'
+import type { PullRequest } from './pull-requests'
 
 /** The background fetch of the base branch: when it last ran, when it last worked and why it failed. */
 export type FetchState = {
@@ -70,12 +72,13 @@ export const fetchNotice = (state: FetchState, baseRef: string, locale: string):
   return `fetch failed (${state.failure}), reading ${baseRef} as it is: ${known}`
 }
 
-/** Fetches the base branch; returns the reason when it did not work, null when it did. Never rejects. */
-export const fetchBase = async (root: string, remote: string, branch: string): Promise<string | null> => {
+/** Fetches `refspecs` from `remote` in one call; returns the reason when it did not work, null when it did or there was nothing to fetch. Never rejects. */
+export const fetchRefs = async (root: string, remote: string, refspecs: readonly string[]): Promise<string | null> => {
+  if (refspecs.length === 0) return null
   let timedOut = false
   let timer: Timer | undefined
   try {
-    const child = Bun.spawn(['git', '-C', root, 'fetch', '--quiet', remote, branch], {
+    const child = Bun.spawn(['git', '-C', root, 'fetch', '--quiet', remote, ...refspecs], {
       stdout: 'ignore',
       stderr: 'pipe',
       env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
@@ -94,3 +97,23 @@ export const fetchBase = async (root: string, remote: string, branch: string): P
     clearTimeout(timer)
   }
 }
+
+/** Fetches the base branch; returns the reason when it did not work, null when it did. Never rejects. */
+export const fetchBase = (root: string, remote: string, branch: string): Promise<string | null> =>
+  fetchRefs(root, remote, [branch])
+
+/**
+ * Fetches the heads of the given pull requests into the herd's own refs (`pullHeadRef`), in one call after the base.
+ * A failure is not reported: a head that was not fetched reads nothing, and the plan stays as the base has it.
+ */
+export const fetchPlanHeads = async (
+  root: string,
+  remote: string,
+  pullRequests: readonly Pick<PullRequest, 'number'>[],
+): Promise<void> => {
+  await fetchRefs(
+    root,
+    remote,
+    pullRequests.map(({ number }) => pullHeadRefspec(number)),
+  )
+}

package/src/plans/git.ts

@@ -35,18 +35,32 @@ export const commitOf = (root: string, ref: string): string | null =>
 /** Reads files as they are at the base ref. */
 export type BaseReader = (path: string) => string | null
 
-let cached: { root: string; commit: string; texts: Map<string, string> } | null = null
+/** How many commits keep their texts: the base ref and the heads of the open pull requests that change a plan. */
+const CACHED_COMMITS = 16
+
+/** The texts read per `root\0commit`, the one asked last at the end. */
+const cachedTexts = new Map<string, Map<string, string>>()
+
+const textsOf = (root: string, commit: string): Map<string, string> => {
+  const key = `${root}\0${commit}`
+  const texts = cachedTexts.get(key) ?? new Map<string, string>()
+  cachedTexts.delete(key)
+  cachedTexts.set(key, texts)
+  const oldest = cachedTexts.keys().next().value
+  if (cachedTexts.size > CACHED_COMMITS && oldest !== undefined) cachedTexts.delete(oldest)
+  return texts
+}
 
 /**
  * A reader for the files at `ref`, with the commit resolved once. A file at a commit never changes, so what was
- * read is kept for as long as the ref points at the same commit: a re-read of the sprint costs one `git
- * rev-parse` instead of one `git show` per plan.
+ * read is kept for as long as the commit is among the last `CACHED_COMMITS` asked: a re-read of the sprint costs
+ * one `git rev-parse` per ref instead of one `git show` per plan, and the base and the pull request heads read in
+ * the same round do not evict each other.
  */
 export const baseReaderOf = (root: string, ref: string): BaseReader => {
   const commit = commitOf(root, ref)
   if (commit === null) return () => null
-  if (cached?.root !== root || cached.commit !== commit) cached = { root, commit, texts: new Map() }
-  const { texts } = cached
+  const texts = textsOf(root, commit)
   return (path) => {
     const kept = texts.get(path)
     if (kept !== undefined) return kept

package/src/plans/herd-claim.ts

@@ -0,0 +1,173 @@
+import { createHash } from 'node:crypto'
+import { readFileSync, readlinkSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
+import { ensurePrivateDirectory, writePrivateFile } from '../../kit/hooks/hooks/shared/private-directory'
+import {
+  type LocationSystem,
+  readPrivateText,
+  runtimeBaseOf,
+  systemLocation,
+  userDirectoryOf,
+} from '../shared/private-location'
+import { HERD_COMMAND } from './herd-command'
+import { CHILD_MARKER, TAKEN_OVER_CODE, TAKEOVER_SIGNAL } from './restart-decision'
+
+const DIRECTORY_PREFIX = 'jackherd-herd'
+const POLL_MS = 50
+const POLLS_BEFORE_KILL = 20
+
+export type ClaimDeps = {
+  selfPid: number
+  prepare: () => void
+  readRecord: () => string | null
+  writeRecord: (pid: number) => void
+  removeRecordIf: (pid: number) => void
+  isHerdView: (pid: number) => boolean
+  isGone: (pid: number) => boolean
+  signal: (pid: number, signal: NodeJS.Signals) => void
+  sleep: (ms: number) => Promise<void>
+  onExit: (run: () => void) => void
+}
+
+/** A process id as the record file holds it; nothing for anything but a positive integer. */
+export const parsePid = (text: string | null): number | null => {
+  if (text === null || !/^\d+\s*$/.test(text)) return null
+  const pid = Number(text)
+  return pid > 0 ? pid : null
+}
+
+/**
+ * The older herd view of this terminal that has to end before `selfPid` draws: the recorded pid when it is not
+ * this process and still is a herd view (a number the system has reused for something else is not).
+ */
+export const olderHerdToStop = (
+  recorded: number | null,
+  selfPid: number,
+  isHerdView: (pid: number) => boolean,
+): number | null => (recorded === null || recorded === selfPid || !isHerdView(recorded) ? null : recorded)
+
+const endOlderHerd = async (pid: number, deps: ClaimDeps): Promise<void> => {
+  deps.signal(pid, TAKEOVER_SIGNAL)
+  for (let poll = 0; poll < POLLS_BEFORE_KILL; poll++) {
+    if (deps.isGone(pid)) return
+    await deps.sleep(POLL_MS)
+  }
+  if (!deps.isGone(pid) && deps.isHerdView(pid)) deps.signal(pid, 'SIGKILL')
+}
+
+/**
+ * Makes this process the one herd view of its terminal: an older one is sent `TAKEOVER_SIGNAL` and, when it has not ended
+ * after about a second and its pid still is a herd view, SIGKILL; then the own pid is recorded and removed again when the process ends. The claim
+ * directory is verified first: a record in a directory of someone else is never read, and a directory that cannot be
+ * verified throws before anything is read, signalled or written.
+ */
+export const claimTerminal = async (deps: ClaimDeps): Promise<void> => {
+  deps.prepare()
+  const older = olderHerdToStop(parsePid(deps.readRecord()), deps.selfPid, deps.isHerdView)
+  if (older !== null) await endOlderHerd(older, deps)
+  deps.writeRecord(deps.selfPid)
+  deps.onExit(() => deps.removeRecordIf(deps.selfPid))
+}
+
+/** The directory holding the claim records: one private level `jackherd-herd-<uid>` below `runtimeBaseOf`. */
+export const claimDirectoryOf = (system: LocationSystem): string =>
+  userDirectoryOf(runtimeBaseOf(system), DIRECTORY_PREFIX, system.uid)
+
+const exitWhenTakenOver = (): void => {
+  process.on(TAKEOVER_SIGNAL, () => process.exit(TAKEN_OVER_CODE))
+}
+
+/**
+ * Runs `start` once the takeover is done; a takeover that cannot be made (no terminal, no `/proc`) does not stop the
+ * view. `listen` runs first, so a newer herd's takeover signal that arrives while the claim is made ends this process
+ * as a wanted end instead of by the signal's default action; the view replaces that handler with its own.
+ */
+export const startExclusive = async (
+  claim: () => Promise<void>,
+  start: () => void,
+  listen: () => void = exitWhenTakenOver,
+): Promise<void> => {
+  listen()
+  try {
+    await claim()
+  } catch {
+    // the view still starts: one stale herd is better than none
+  }
+  start()
+}
+
+const terminalOfStdin = (): string | null => {
+  try {
+    const target = readlinkSync('/proc/self/fd/0')
+    return target.startsWith('/dev/') ? target : null
+  } catch {
+    return null
+  }
+}
+
+const readText = (path: string): string | null => {
+  try {
+    return readFileSync(path, 'utf8')
+  } catch {
+    return null
+  }
+}
+
+const isHerdViewProcess = (pid: number): boolean => {
+  const environment = readText(`/proc/${pid}/environ`)
+  const command = readText(`/proc/${pid}/cmdline`)
+  if (environment === null || command === null) return false
+  return environment.split('\0').includes(`${CHILD_MARKER}=1`) && command.split('\0').includes(HERD_COMMAND.name)
+}
+
+const isGoneProcess = (pid: number): boolean => {
+  const stat = readText(`/proc/${pid}/stat`)
+  if (stat === null) return true
+  const stateIndex = stat.lastIndexOf(')') + 2
+  return stat.charAt(stateIndex) === 'Z'
+}
+
+const signalProcess = (pid: number, signal: NodeJS.Signals): void => {
+  try {
+    process.kill(pid, signal)
+  } catch {
+    // already gone
+  }
+}
+
+const recordFileOf = (terminal: string): string =>
+  join(claimDirectoryOf(systemLocation()), `${createHash('sha256').update(terminal).digest('hex').slice(0, 16)}.pid`)
+
+/**
+ * The claim operations for one record file; the claim directory is verified before the record is read or written, and
+ * a record that is a link or a FIFO is not read.
+ */
+export const herdClaimDeps = (file: string): ClaimDeps => ({
+  selfPid: process.pid,
+  prepare: () => ensurePrivateDirectory(join(file, '..')),
+  readRecord: () => readPrivateText(file),
+  writeRecord: (pid) => {
+    ensurePrivateDirectory(join(file, '..'))
+    writePrivateFile(file, `${pid}\n`)
+  },
+  removeRecordIf: (pid) => {
+    try {
+      if (parsePid(readPrivateText(file)) === pid) unlinkSync(file)
+    } catch {
+      // the next herd of this terminal overwrites it
+    }
+  },
+  isHerdView: isHerdViewProcess,
+  isGone: isGoneProcess,
+  signal: signalProcess,
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  onExit: (run) => {
+    process.on('exit', run)
+  },
+})
+
+/** Takes the terminal of stdin over from an older herd view; without a terminal (or `/proc`) it does nothing. */
+export const claimOwnTerminal = async (): Promise<void> => {
+  const terminal = terminalOfStdin()
+  if (terminal !== null) await claimTerminal(herdClaimDeps(recordFileOf(terminal)))
+}

package/src/plans/herd-memory.ts

@@ -1,14 +1,19 @@
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
+import { dirname, join } from 'node:path'
 import { z } from 'zod'
+import { ensurePrivateDirectory, writePrivateFile } from '../../kit/hooks/hooks/shared/private-directory'
+import {
+  ensurePrivateLevels,
+  type LocationSystem,
+  readPrivateText,
+  runtimeBaseOf,
+  systemLocation,
+  userDirectoryOf,
+} from '../shared/private-location'
 import { repositoryKey } from '../watch/watcher-lock'
 import type { LaneMemory } from './current-phase'
 
 const DIRECTORY_PREFIX = 'jackherd-herd'
 const MEMORY_FILE = 'herd-memory.json'
-const PRIVATE_DIRECTORY = 0o700
-const PRIVATE_FILE = 0o600
 
 const phaseRef = z.object({ planHref: z.string(), phaseId: z.string() })
 
@@ -54,41 +59,46 @@ export const mergedMemories = (
  * Where the herds of the repository at `root` keep what they saw of each lane, one directory per user and
  * repository like the watcher's, so a `--once` run and a restarted herd know when a phase last moved.
  */
-const herdMemoryDirectory = (root: string): string =>
-  join(tmpdir(), `${DIRECTORY_PREFIX}-${process.getuid?.() ?? 'user'}`, repositoryKey(root))
+export const herdMemoryDirectoryOf = (root: string, system: LocationSystem): string =>
+  join(userDirectoryOf(runtimeBaseOf(system), DIRECTORY_PREFIX, system.uid), repositoryKey(root))
 
-export const memoryFileOf = (directory: string): string => join(directory, MEMORY_FILE)
-
-const readText = (file: string): string | null => {
-  try {
-    return readFileSync(file, 'utf8')
-  } catch {
-    return null
-  }
+/** The memory directory of `root` with both levels verified private (`ensurePrivateLevels`); throws when one is not. */
+const ensureHerdMemoryDirectory = (root: string, system: LocationSystem): string => {
+  const directory = herdMemoryDirectoryOf(root, system)
+  return ensurePrivateLevels(dirname(directory), directory)
 }
 
+export const memoryFileOf = (directory: string): string => join(directory, MEMORY_FILE)
+
 export const readLaneMemories = (directory: string): Map<string, LaneMemory> =>
-  parseLaneMemories(readText(memoryFileOf(directory)))
+  parseLaneMemories(readPrivateText(memoryFileOf(directory)))
 
 /**
  * Writes the memories of `lanes` into the file of `directory`, beside what other herds keep there; readable by the
- * user only, and replaced in one step so a herd reading at the same time never sees half a file.
+ * user only (the directory is verified with `ensurePrivateDirectory`), and replaced in one step through
+ * `writePrivateFile`, so a herd reading at the same time never sees half a file and a planted link is never followed.
  */
 export const writeLaneMemories = (
   directory: string,
   memories: ReadonlyMap<string, LaneMemory>,
   lanes: readonly string[],
 ): void => {
-  mkdirSync(directory, { recursive: true, mode: PRIVATE_DIRECTORY })
-  const file = memoryFileOf(directory)
+  ensurePrivateDirectory(directory)
   const merged = mergedMemories(readLaneMemories(directory), memories, lanes)
-  const partial = `${file}.${process.pid}`
-  writeFileSync(partial, JSON.stringify(merged), { mode: PRIVATE_FILE })
-  renameSync(partial, file)
+  writePrivateFile(memoryFileOf(directory), JSON.stringify(merged))
 }
 
-/** The memories the herds of the repository at `root` kept. */
-export const recallLanes = (root: string): Map<string, LaneMemory> => readLaneMemories(herdMemoryDirectory(root))
+/**
+ * The memories the herds of the repository at `root` kept; none when the directory cannot be verified private, so a
+ * file planted in a directory of someone else is never read.
+ */
+export const recallLanes = (root: string, system: LocationSystem = systemLocation()): Map<string, LaneMemory> => {
+  try {
+    return readLaneMemories(ensureHerdMemoryDirectory(root, system))
+  } catch {
+    return new Map()
+  }
+}
 
 /**
  * Keeps the memories of `lanes` for the next herd. A memory that cannot be written costs only the times of the next
@@ -98,9 +108,10 @@ export const rememberLanes = (
   root: string,
   memories: ReadonlyMap<string, LaneMemory>,
   lanes: readonly string[],
+  system: LocationSystem = systemLocation(),
 ): void => {
   try {
-    writeLaneMemories(herdMemoryDirectory(root), memories, lanes)
+    writeLaneMemories(ensureHerdMemoryDirectory(root, system), memories, lanes)
   } catch {
     return
   }

package/src/plans/lane-plans.ts

@@ -1,8 +1,10 @@
 import { existsSync, statSync } from 'node:fs'
 import { join } from 'node:path'
-import { type PlansByHref, parsePlanPhases, resolvePlanPath, type SprintLane } from '../plan-format'
+import { type PlanPhase, type PlansByHref, resolvePlanPath, type SprintLane } from '../plan-format'
 import type { BaseReader } from './git'
-import { hasOwnWork, mergePlanPhases } from './phase-source'
+import { hasOwnWork, mergePlanPhases, newerPhases } from './phase-source'
+import { type PlanRound, parsedPlanPhases } from './plan-cache'
+import type { PlanHead } from './plan-heads'
 import type { PlansSettings } from './settings'
 
 /** Paths that could not be read at the base ref and were read from a checkout instead. */
@@ -10,8 +12,20 @@ export type Fallbacks = string[]
 
 export type LaneWork = { worktree: string | null; ahead: number | null; dirty: number }
 
+/** Parses a plan's text, kept under `key` in the round's cache. */
+type ParsePlan = (markdown: string, key: string) => PlanPhase[]
+
 /** What reading a lane's plans needs: the main checkout, the settings, the base ref's reader, the board's directory. */
-export type PlanSources = { root: string; settings: PlansSettings; base: BaseReader; sprintDirectory: string }
+export type PlanSources = {
+  root: string
+  settings: PlansSettings
+  base: BaseReader
+  sprintDirectory: string
+  /** The heads of the open pull requests that change a plan, besides the lane's own; a phase they ticked further counts. */
+  heads: readonly PlanHead[]
+  /** Kept between reads, so a plan whose text did not change is not parsed again; `used` collects the keys of one round. */
+  parsed?: PlanRound
+}
 
 const isOutsideRepository = (path: string): boolean => path.startsWith('..')
 
@@ -49,10 +63,30 @@ export const laneWorkOf = (worktree: string, status: { ahead: number | null; dir
 })
 
 /**
- * The plans of a lane. The base ref is the truth; while the lane has work of its own in its worktree, the phases
- * its rows name, and those new there or ticked further, come from the worktree (`mergePlanPhases`). A plan the base ref lacks is read from the lane's worktree, else from the main
- * checkout (a repository that ignores `docs/` keeps plan and board only there). `files` are the plan files to
- * watch for changes, `modified` when each was last written, by plan link (`nextActivity` bounds a movement by it).
+ * The base's phases with each phase an open pull request ticked further taken from that pull request's head, in
+ * the heads' order. A head whose ref was not fetched reads nothing and changes nothing; its phases are never the
+ * lane's work, so none is marked `touched`.
+ */
+const withPullRequestHeads = (
+  base: PlanPhase[],
+  heads: readonly PlanHead[],
+  path: string,
+  parse: ParsePlan,
+): PlanPhase[] =>
+  heads
+    .filter((head) => head.files.includes(path))
+    .reduce((phases, head) => {
+      const headText = head.read(path)
+      return headText === null ? phases : newerPhases(phases, parse(headText, `${path}\0pr${head.number}`))
+    }, base)
+
+/**
+ * The plans of a lane. The base ref is the truth, raised by the heads of open pull requests that ticked a phase
+ * further (`withPullRequestHeads`); while the lane has work of its own in its worktree, the phases its rows name,
+ * and those new there or ticked further, come from the worktree (`mergePlanPhases`). A plan the base ref lacks is
+ * read from the lane's worktree, else from the main checkout (a repository that ignores `docs/` keeps plan and
+ * board only there). `files` are the plan files to watch for changes, `modified` when each was last written, by
+ * plan link (`nextActivity` bounds a movement by it).
  */
 export const readPlans = async (lane: SprintLane, sources: PlanSources, work: LaneWork, fallbacks: Fallbacks) => {
   const { root, settings, sprintDirectory } = sources
@@ -68,12 +102,9 @@ export const readPlans = async (lane: SprintLane, sources: PlanSources, work: La
     if (text === null) continue
     const own = worktreeFile === file && hasOwnWork(work) ? await Bun.file(file).text() : null
     const laneIds = lane.steps.filter((step) => step.planHref === href).flatMap((step) => step.phaseIds)
-    plans[href] = mergePlanPhases(
-      parsePlanPhases(text, settings.planLanguage),
-      own === null ? null : parsePlanPhases(own, settings.planLanguage),
-      laneIds,
-      work,
-    )
+    const parse: ParsePlan = (markdown, key) => parsedPlanPhases(sources.parsed, key, markdown, settings.planLanguage)
+    const base = withPullRequestHeads(parse(text, path), sources.heads, path, parse)
+    plans[href] = mergePlanPhases(base, own === null ? null : parse(own, `${file}\0own`), laneIds, work)
     files.push(file)
     texts[href] = text
     if (existsSync(file)) modified[href] = statSync(file).mtimeMs

package/src/plans/lane-standing.ts

@@ -45,15 +45,20 @@ 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, an open pull request or
- * uncommitted changes in its worktree make a lane active (a small fix has no agent in herdr) 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
   const editedInWorktree = status.branch !== null && status.dirty > 0
-  if (progress.lane.closed) return working || status.branch !== null ? LANE_STANDING.noAgent : LANE_STANDING.closed
+  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