jackherd 1.8.1 → 1.10.0

package/src/plans/snapshot.ts

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import type { ContextReading } from '../context'
 import { type AgentLogReader, contextOfAgent } from '../context/report'
-import { agentLog } from '../context/session-log'
+import { agentLog, defaultProjectsDirectory } from '../context/session-log'
 import {
   type LaneProgress,
   laneProgress,
@@ -13,9 +13,14 @@ import {
   shortTitle,
   sprintTitleOf,
 } from '../plan-format'
+import type { WaitingItem } from '../plan-format/waiting'
+import { dropUnused } from '../shared/stat-cache'
+import type { TaskSignal } from '../task-signals/types'
 import type { LaneAgent, LaneStatusSource } from '../terminal'
 import type { SourceTicket, WatchBadges, WatchHealth } from '../watch/plan-badges'
 import { readWatchReading } from '../watch/plan-badges-read'
+import { assignSignals, laneOfDirectory, type UnplannedTask } from './active-tasks'
+import { type AppointmentBlock, appointmentBlock } from './appointment-rows'
 import { boardRowsOf } from './board-rows'
 import {
   type ActivityTimes,
@@ -26,21 +31,39 @@ import {
   type PlanModified,
   withMovedPhase,
 } from './current-phase'
+import { activityTextOf, taskSignalsOf } from './current-task'
 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 {
+  type Fallbacks,
+  laneWorkOf,
+  type PlanSources,
+  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 type { LaneView } 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 { laneHeads, planPullRequests, readerOncePerRef } from './plan-heads'
 import { type PlannedPlan, plannedPlans } from './planned'
+import type { PullRequest } from './pull-requests'
+import type { ReadCache } from './read-cache'
+import { type SentChip, sentChipsByLane } from './sent-files'
 import { baseRefOf, boardRepoPathOf, type PlansSettings, worktreeOf } from './settings'
+import { signalledTitle } from './signalled-phase'
+import { readAllSignals } from './signals-read'
+import type { SubagentActivity } from './subagents'
+import { readSubagentActivity, subagentSourceOf } from './subagents-read'
 import { boardTexts } from './texts'
 import { type UnlistedLane, unlistedLanes, unlistedSprintLane } from './unlisted-lanes'
+import { readWaitingRecords, waitingItemsOf } from './waiting-records'
 import { withWorkedPhases } from './worked-phases'
 
 /** Where the view reads from: the main checkout, the sprint document, the command line and the project settings. */
@@ -52,6 +75,10 @@ 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
+  /** The worktrees subagents of the coordinator work in; defaults to reading them from `~/.claude/projects`. */
+  readSubagents?: (root: string, worktreeDirectory: string) => Map<string, SubagentActivity>
+  /** What agents report doing (Claude's task lists, `jh task`); defaults to reading `~/.claude/projects` and `.jackherd/tasks/`. */
+  readSignals?: (root: string, worktreeDirectory: string, now: number) => TaskSignal[]
 }
 
 /**
@@ -86,6 +113,12 @@ 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
+  /** What waits on the user's answer: the open rows of the board's section for it, from the checkout's board file. */
+  waiting?: WaitingItem[]
+  /** The board's open appointments, read from the same board text as `waiting`, for the block under it. */
+  appointments?: AppointmentBlock
+  /** What agents report doing that no lane takes: the coordinator's own, or a lane the board does not list. */
+  unplaced?: UnplannedTask[]
 }
 
 type LaneSources = {
@@ -93,32 +126,77 @@ type LaneSources = {
   base: BaseReader
   sprintDirectory: string
   agents: LaneAgent[]
+  /** What subagents of the coordinator do in each worktree; a herdr agent in the worktree comes first. */
+  subagents: Map<string, SubagentActivity>
+  /** The agents' log reader, asking once per agent however often the read is used in one snapshot. */
+  readLog: AgentLogReader
   pullRequests: PullRequestState
+  /** The open pull requests that change a plan, whose heads raise the ticks the base ref has. */
+  planPullRequests: PullRequest[]
+  /** The reader of a pull request head, resolved once per read whatever the number of lanes. */
+  headReaderOf: (ref: string) => BaseReader
+  /** What agents report doing, in every lane and outside them. */
+  signals: TaskSignal[]
+  /** The directory the lanes' worktrees lie in, which tells a signal's lane. */
+  worktrees: string
+  parsed?: PlanSources['parsed']
 }
 
-type BoardLanes = { markdown: string; lanes: SprintLane[] }
+/** `liveMarkdown` is the checkout's board file (the coordinator edits it before any commit), else `markdown`. */
+type BoardLanes = { markdown: string; liveMarkdown: string; lanes: SprintLane[] }
 
 const SHOWN_NAMES = 2
 
 type LaneResult = { view: LaneView; files: string[]; texts: Record<string, string>; pane: string | null }
 
+/** The board's lanes the view shows, the running lanes it does not list, and what the lanes read from. */
+type LaneSet = { lanes: SprintLane[]; unlisted: UnlistedLane[]; sources: LaneSources; errors: string[] }
+
+/** What a lane's view is decorated with after it was read. */
+type Decorations = {
+  reading: ReturnType<typeof readWatchReading> | null
+  phaseModels: readonly PhaseModelRecord[]
+  sprintDirectory: string
+  sentChips: ReadonlyMap<string | null, SentChip[]>
+}
+
 /** How full the agent's context is, null when the terminal gave no session or the session has no log. */
-const contextOf = (agent: LaneAgent | undefined, source: Source): ContextReading | null => {
-  const report = contextOfAgent(agent, source.readAgentLog ?? agentLog, source.settings.context)
+const contextOf = (agent: LaneAgent | undefined, source: Source, readLog: AgentLogReader): ContextReading | null => {
+  const report = contextOfAgent(agent, readLog, source.settings.context)
   return report && { share: report.share, level: report.level }
 }
 
+/** A reader that asks once per agent (session and directory), so context and task signal share one read of a large log. */
+const onceReader = (read: AgentLogReader): AgentLogReader => {
+  const answers = new Map<string, string[] | null>()
+  return (agent) => {
+    const key = `${agent.session}\0${agent.cwd}`
+    if (!answers.has(key)) answers.set(key, read(agent))
+    return answers.get(key) ?? null
+  }
+}
+
+const WORK_ENTRIES = 40
+
+/** What the agents of a lane did lately: the end of its own agent's log and the log ends of subagents working in its worktree. */
+const workText = ({ readLog, subagents }: LaneSources, lane: string, agent: LaneAgent | undefined): string => {
+  const lines = agent ? readLog(agent) : null
+  return [lines ? activityTextOf(lines, WORK_ENTRIES) : '', subagents.get(lane)?.activity ?? ''].join(' ')
+}
+
 /** 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
   const gitStatus = await gitStatusOf(worktreeOf(source.root, source.settings, name), baseRefOf(source.settings))
+  const subagent = agent ? undefined : sources.subagents.get(name)
+  const title = agent?.title ?? subagent?.description
   return {
     gitStatus,
     view: {
-      status: { agent: agent?.status ?? null, ...gitStatus },
-      ...(agent?.title ? { sessionTitle: agent.title } : {}),
+      status: { agent: agent?.status ?? subagent?.status ?? null, ...gitStatus },
+      ...(title ? { sessionTitle: title } : {}),
       pullRequests: gitStatus.branch ? (pullRequests.byBranch.get(gitStatus.branch) ?? []) : [],
-      context: contextOf(agent, source),
+      context: contextOf(agent, source, sources.readLog),
     },
   }
 }
@@ -163,19 +241,41 @@ const laneView = async (
     modified,
   } = await readPlans(
     lane,
-    { root, settings, base: sources.base, sprintDirectory: sources.sprintDirectory },
+    {
+      root,
+      settings,
+      base: sources.base,
+      sprintDirectory: sources.sprintDirectory,
+      heads: laneHeads(sources.planPullRequests, gitStatus.branch, sources.headReaderOf),
+      parsed: sources.parsed,
+    },
     laneWorkOf(worktree, gitStatus),
     fallbacks,
   )
   const shown = withWorkedPhases(lane, phasesByHref)
   const { progress, activity } = progressWithMemory(shown, phasesByHref, memories, { now, modified })
+  const laneSubagents = sources.subagents.get(lane.name)
   const view: LaneView = {
     progress,
     ...running,
     chips: Object.fromEntries(
       Object.entries(texts).map(([href, text]) => [href, extractLinkChips(text, settings.linkKinds)]),
     ),
-    summary: laneSummary({ progress, phases: phasesByHref, texts, activity, language: settings.planLanguage }, now),
+    summary: laneSummary(
+      {
+        progress,
+        phases: phasesByHref,
+        activity,
+        guesses: taskSignalsOf(Object.values(phasesByHref).flat(), workText(sources, lane.name, agent), now),
+        reported: sources.signals.filter(({ cwd }) => laneOfDirectory(cwd, sources.worktrees) === lane.name),
+        subagents: laneSubagents?.phaseRuns ?? [],
+        subagentTasks: laneSubagents?.taskDescriptions ?? [],
+        phaselessReviews: laneSubagents?.phaselessReviews ?? [],
+        describedSubagents: laneSubagents?.describedSubagents ?? [],
+        branch: gitStatus.branch,
+      },
+      now,
+    ),
   }
   return { view, files, texts, pane: agent?.pane ?? null }
 }
@@ -185,14 +285,14 @@ const laneView = async (
  * and without phases, marked as unlisted.
  */
 const unlistedView = async (sources: LaneSources, { name, agent }: UnlistedLane): Promise<LaneResult> => {
-  const { view: running } = await runningState(sources, name, agent)
+  const { view: running } = await runningState(sources, name, agent ?? undefined)
   const view: LaneView = {
     progress: laneProgress(unlistedSprintLane(name), {}),
     ...running,
     chips: {},
     unlisted: true,
   }
-  return { view, files: [], texts: {}, pane: agent.pane }
+  return { view, files: [], texts: {}, pane: agent?.pane ?? null }
 }
 
 /** The view with the watcher's badges of its own pull requests, only when there are any, so it otherwise stays as it was. */
@@ -223,6 +323,35 @@ const withTickets = (result: LaneResult, tickets: readonly SourceTicket[]): Lane
   return found ? { ...view, chips: withoutTicketLinks(view.chips, found), tickets: found } : view
 }
 
+/** What agents report doing; nothing when it cannot be read. */
+const readSignals = (
+  { root, readSignals: read }: Source,
+  worktrees: string,
+  now: number,
+  cache?: ReadCache,
+): TaskSignal[] => {
+  try {
+    return (
+      read ??
+      ((main, directory, at) =>
+        readAllSignals({ projects: defaultProjectsDirectory(), root: main, worktrees: directory }, at, cache?.signals))
+    )(root, worktrees, now)
+  } catch {
+    return []
+  }
+}
+
+/** The reports no shown lane takes, as lines for the overview: the coordinator's own and those of lanes without a plan. */
+const unplacedOf = (sources: LaneSources, lanes: readonly SprintLane[], onlyLane: boolean): UnplannedTask[] => {
+  if (onlyLane) return []
+  const listed = new Set(lanes.map((lane) => lane.name))
+  const rest = sources.signals.filter(({ cwd }) => {
+    const lane = laneOfDirectory(cwd, sources.worktrees)
+    return lane === null || !listed.has(lane)
+  })
+  return assignSignals([], rest).unplanned
+}
+
 /** The terminal's agents, or none with the reason when it cannot be asked, so the screen says why lanes show "no agent". */
 const readAgents = (terminal: LaneStatusSource): { agents: LaneAgent[]; errors: string[] } => {
   try {
@@ -232,6 +361,26 @@ const readAgents = (terminal: LaneStatusSource): { agents: LaneAgent[]; errors:
   }
 }
 
+/** What subagents of the coordinator do in the worktrees; nothing when their logs cannot be read. */
+const readSubagents = (
+  { root, settings, readSubagents: read }: Source,
+  worktrees: string,
+): Map<string, SubagentActivity> => {
+  try {
+    return (
+      read ?? ((main, directory) => readSubagentActivity(subagentSourceOf(main, directory, settings.skillPrefix)))
+    )(root, worktrees)
+  } catch {
+    return new Map()
+  }
+}
+
+/** The view with the files its session sent to the user, only when there are any, so it otherwise stays as it was. */
+const withSentFiles = (view: LaneView, chips: ReadonlyMap<string | null, SentChip[]>): LaneView => {
+  const found = chips.get(view.progress.lane.name)
+  return found ? { ...view, sentFiles: found } : view
+}
+
 /** Up to two names, then how many more: `a, b and 3 more`. */
 const namedWithMore = (names: readonly string[]): string => {
   const more = names.length - SHOWN_NAMES
@@ -259,8 +408,8 @@ const readBoardLanes = async (
   const { sprintFile, settings } = source
   const atBase = textAtBase(base, boardPath)
   const markdown = atBase ?? (await readFallback(boardPath, sprintFile, fallbacks)) ?? ''
-  const checkoutText = atBase !== null && existsSync(sprintFile) ? await Bun.file(sprintFile).text() : markdown
-  return { markdown, lanes: boardRowsOf(markdown, checkoutText, settings.planLanguage).lanes }
+  const liveMarkdown = atBase !== null && existsSync(sprintFile) ? await Bun.file(sprintFile).text() : markdown
+  return { markdown, liveMarkdown, lanes: boardRowsOf(markdown, liveMarkdown, settings.planLanguage).lanes }
 }
 
 /** The plans the sprint's plans tables name, read at the base ref, by link; lanes read theirs themselves. */
@@ -291,83 +440,153 @@ const forgetLanes = (memories: Map<string, LaneMemory> | undefined, lanes: reado
   for (const name of [...(memories?.keys() ?? [])]) if (!names.has(name)) memories?.delete(name)
 }
 
+const laneSetOf = (
+  source: Source,
+  context: {
+    base: BaseReader
+    board: BoardLanes
+    sprintDirectory: string
+    worktrees: string
+    cache?: ReadCache
+  },
+  pullRequests: PullRequestState,
+  now: number,
+): LaneSet => {
+  const { base, board, sprintDirectory, worktrees, cache } = context
+  const { agents, errors } = readAgents(source.terminal)
+  const isWanted = ({ name }: { name: string }) => !source.options.lane || name === source.options.lane
+  const subagents = readSubagents(source, worktrees)
+  const listed = new Set(board.lanes.map((lane) => lane.name))
+  return {
+    lanes: board.lanes.filter(isWanted),
+    unlisted: unlistedLanes(agents, listed, worktrees, new Set(subagents.keys())).filter(isWanted),
+    sources: {
+      source,
+      base,
+      sprintDirectory,
+      agents,
+      subagents,
+      readLog: onceReader(source.readAgentLog ?? agentLog),
+      pullRequests,
+      planPullRequests: planPullRequests([...pullRequests.byBranch.values()].flat(), source.settings.planDirectory),
+      headReaderOf: readerOncePerRef((ref) => baseReaderOf(source.root, ref)),
+      signals: readSignals(source, worktrees, now, cache),
+      worktrees,
+      parsed: cache && { entries: cache.plans, used: new Set<string>() },
+    },
+    errors,
+  }
+}
+
+/** The views of the listed lanes, then of the unlisted ones; the lanes' memories are cleaned of lanes the board dropped. */
+const laneResultsOf = async (
+  { lanes, unlisted, sources }: LaneSet,
+  fallbacks: Fallbacks,
+  now: number,
+  memories: Map<string, LaneMemory> | undefined,
+): Promise<LaneResult[]> => {
+  const results = [
+    ...(await Promise.all(lanes.map((lane) => laneView(sources, lane, fallbacks, now, memories)))),
+    ...(await Promise.all(unlisted.map((lane) => unlistedView(sources, lane)))),
+  ]
+  forgetLanes(memories, lanes)
+  return results
+}
+
+/** Each lane's view with its tickets, the watcher's badges, its phases' models and the files sent from it. */
+const decoratedViews = (
+  results: readonly LaneResult[],
+  { reading, phaseModels, sprintDirectory, sentChips }: Decorations,
+): LaneView[] =>
+  results.map((result) =>
+    withSentFiles(
+      withModels(
+        withBadges(withTickets(result, reading?.tickets ?? []), reading?.badges ?? {}),
+        phaseModels,
+        sprintDirectory,
+      ),
+      sentChips,
+    ),
+  )
+
+/** The open phases no lane with an agent leads; none while the view shows one lane. */
+const plannedOf = (
+  source: Source,
+  plans: Record<string, string>,
+  results: readonly LaneResult[],
+  sprintDirectory: string,
+): PlannedPlan[] =>
+  source.options.lane
+    ? []
+    : plannedPlans({
+        plans,
+        lanes: results.map(({ view }) => ({ lane: view.progress.lane, agent: view.status.agent })),
+        sprintDirectory,
+        language: source.settings.planLanguage,
+      })
+
 /**
  * Reads the board, its plans and the lanes' state. `memories` holds, per lane, what the herd saw at the last read; it
  * is how the current phase becomes the one whose boxes moved since, and it is cleaned of lanes the board dropped.
+ * `cache`, kept by the caller between reads, spares parsing the session logs and plans that did not change.
  */
 export const loadSnapshot = async (
   source: Source,
   pullRequests: PullRequestState,
   memories?: Map<string, LaneMemory>,
+  cache?: ReadCache,
 ): Promise<Snapshot> => {
-  const { root, sprintFile, options, settings, terminal } = source
+  const { root, sprintFile, options, settings } = source
   const fallbacks: Fallbacks = []
-  const base = baseReaderOf(root, baseRefOf(settings))
+  const baseRef = baseRefOf(settings)
+  const base = baseReaderOf(root, baseRef)
   const boardPath = boardRepoPathOf(root, settings, sprintFile)
   const board = await readBoardLanes(source, base, boardPath, fallbacks)
   const { markdown } = board
   const sprintDirectory = dirname(boardPath)
-  const { agents, errors } = readAgents(terminal)
-  const isWanted = ({ name }: { name: string }) => !options.lane || name === options.lane
-  const lanes = board.lanes.filter(isWanted)
-  const unlisted = unlistedLanes(
-    agents,
-    new Set(board.lanes.map((lane) => lane.name)),
-    join(root, settings.worktreeDirectory),
-  ).filter(isWanted)
-  const sources = {
-    source,
-    base,
-    sprintDirectory,
-    agents,
-    pullRequests,
-  }
+  const worktrees = join(root, settings.worktreeDirectory)
   const now = Date.now()
-  const results = [
-    ...(await Promise.all(lanes.map((lane) => laneView(sources, lane, fallbacks, now, memories)))),
-    ...(await Promise.all(unlisted.map((lane) => unlistedView(sources, lane)))),
-  ]
-  forgetLanes(memories, lanes)
+  const liveBoard = board.liveMarkdown
+  const laneSet = laneSetOf(source, { base, board, sprintDirectory, worktrees, cache }, pullRequests, now)
+  const results = await laneResultsOf(laneSet, fallbacks, now, memories)
+  const { parsed } = laneSet.sources
+  if (parsed) dropUnused(parsed.entries, parsed.used)
   const listedPlans = await readListedPlans(source, base, sprintDirectory, markdown, fallbacks)
   const documentsPlans = Object.assign({}, listedPlans, ...results.map((result) => result.texts))
-  const planned = options.lane
-    ? []
-    : plannedPlans({
-        plans: documentsPlans,
-        lanes: results.map(({ view }) => ({ lane: view.progress.lane, agent: view.status.agent })),
-        sprintDirectory,
-        language: settings.planLanguage,
-      })
   const { ticketSources } = settings
   const watched = ticketSources.length > 0 || results.some(({ view }) => view.pullRequests.length > 0)
   const reading = watched ? readWatchReading(root, now, ticketSources) : null
-  const phaseModels = readPhaseModels(root)
-  const baseRef = baseRefOf(settings)
+  const waitingRecords = readWaitingRecords(root)
+  const sentChips = sentChipsByLane(waitingRecords.sent, worktrees, now)
   const notice = fallbacks.length > 0 ? fallbackNotice(fallbacks, baseRef, refExists(root, baseRef)) : null
   const unknownLaneTitle =
     options.lane && results.length === 0 ? boardTexts(settings.board.term).laneNotListed(options.lane) : null
   return {
     title: unknownLaneTitle ?? sprintTitleOf(markdown, sprintDirectory),
-    views: sortByUrgency(
-      results.map((result) =>
-        withModels(
-          withBadges(withTickets(result, reading?.tickets ?? []), reading?.badges ?? {}),
-          phaseModels,
-          sprintDirectory,
-        ),
-      ),
-    ),
+    views: decoratedViews(results, {
+      reading,
+      phaseModels: readPhaseModels(root),
+      sprintDirectory,
+      sentChips,
+    }),
     documents: {
       sprint: markdown,
       plans: documentsPlans,
-      laneOrder: [...lanes, ...unlisted].map((lane) => lane.name),
+      laneOrder: [...laneSet.lanes, ...laneSet.unlisted].map((lane) => lane.name),
       lanes: board.lanes,
     },
-    planned,
+    planned: plannedOf(source, documentsPlans, results, sprintDirectory),
     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] : [])],
+    titles: new Map(
+      results.flatMap(({ view, pane }) =>
+        pane ? [[pane, signalledTitle(view.summary?.signalled ?? null, shortTitle(view.progress))]] : [],
+      ),
+    ),
+    errors: [...laneSet.errors, ...pullRequests.errors, ...(notice ? [notice] : [])],
     watch: reading?.health,
+    waiting: waitingItemsOf(liveBoard, settings.planLanguage, waitingRecords, now),
+    appointments: appointmentBlock(liveBoard, settings.planLanguage, new Date(now)),
+    unplaced: unplacedOf(laneSet.sources, laneSet.lanes, Boolean(options.lane)),
     ...(ticketSources.length > 0 ? { watchesTickets: true } : {}),
   }
 }

package/src/plans/sprint-export.ts

@@ -1,7 +1,7 @@
-import { mkdirSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
 import { dirname } from 'node:path'
 import { pathToFileURL } from 'node:url'
+import { ensurePrivateDirectory, writePrivateFile } from '../../kit/hooks/hooks/shared/private-directory'
+import { pageDirectoryOf, systemLocation } from '../shared/private-location'
 import { openInBrowser } from '../terminal/open'
 import { errorText } from './error-text'
 import { baseRefInfo, remoteBlobBase } from './git'
@@ -11,19 +11,19 @@ import { renderPlanBody, renderSprintHtml } from './sprint-html'
 import { buildSprintPage, type SprintPage, sprintPagePath } from './sprint-page'
 import { boardTexts } from './texts'
 
-const DIRECTORY_MODE = 0o700
-const FILE_MODE = 0o600
-
-/** What writing and opening the page needs from outside; the defaults are the real ones. */
+/**
+ * What writing and opening the page needs from outside; the defaults are the real ones. `pageDirectory` is the
+ * user's own directory the page goes into, verified private before anything is written.
+ */
 export type ExportEnvironment = {
   now: () => Date
-  temporaryDirectory: string
+  pageDirectory: string
   open: (target: string) => string | null
 }
 
 const systemEnvironment = (): ExportEnvironment => ({
   now: () => new Date(),
-  temporaryDirectory: tmpdir(),
+  pageDirectory: pageDirectoryOf(systemLocation()),
   open: (target) => openInBrowser(target),
 })
 
@@ -46,10 +46,10 @@ const writePage = (
   { sprintFile, root, settings }: Source,
   environment: ExportEnvironment,
 ): WrittenPage | { error: string } => {
-  const path = sprintPagePath(environment.temporaryDirectory, dirname(boardRepoPathOf(root, settings, sprintFile)))
+  const path = sprintPagePath(environment.pageDirectory, dirname(boardRepoPathOf(root, settings, sprintFile)))
   try {
-    mkdirSync(dirname(path), { recursive: true, mode: DIRECTORY_MODE })
-    writeFileSync(path, renderSprintHtml(page), { mode: FILE_MODE })
+    ensurePrivateDirectory(environment.pageDirectory)
+    writePrivateFile(path, renderSprintHtml(page))
   } catch (error) {
     return { error: errorText(error) }
   }

package/src/plans/sprint-page.ts

@@ -16,6 +16,7 @@ import type { PlanLanguage } from '../vocabulary'
 import type { LaneView } from './layout'
 import { extractLinkChips, type LinkChip } from './link-chips'
 import { planAnchorOf } from './markdown-html'
+import { mainPhaseIdOf } from './phase-ids'
 import type { PullRequest } from './pull-requests'
 import type { Snapshot } from './snapshot'
 
@@ -150,14 +151,13 @@ const uniqueId = (base: string, taken: Set<string>): string => {
 }
 
 const phaseOf = (phase: PhaseProgress, dependencies: Record<string, string>): PagePhase => {
-  const numbered = phase.id.replace(/[a-z]$/, '')
   return {
     id: phase.id,
     title: phase.title,
     done: phase.done,
     total: phase.total,
     items: phase.items,
-    dependsOn: dependencies[phase.id] ?? dependencies[numbered] ?? null,
+    dependsOn: dependencies[phase.id] ?? dependencies[mainPhaseIdOf(phase.id)] ?? null,
   }
 }
 
@@ -282,6 +282,6 @@ export const buildSprintPage = (snapshot: Snapshot, context: PageContext): Sprin
   }
 }
 
-/** The file the page is written to: `<temporary directory>/jackherd/<board directory>.html`. */
-export const sprintPagePath = (temporaryDirectory: string, sprintDirectory: string): string =>
-  join(temporaryDirectory, 'jackherd', `${posix.basename(sprintDirectory) || 'board'}.html`)
+/** The file the page is written to: `<page directory>/<board directory>.html`. */
+export const sprintPagePath = (pageDirectory: string, sprintDirectory: string): string =>
+  join(pageDirectory, `${posix.basename(sprintDirectory) || 'board'}.html`)