jackherd 0.0.1 → 1.0.1

package/src/plans/command.ts

@@ -0,0 +1,60 @@
+import { homedir } from 'node:os'
+import { TERMINAL_ADAPTER } from '../config/schema'
+import { laneStatusSourceFor } from '../terminal'
+import { startedKit } from '../version/started-kit'
+import { boardFor, foundLanesOf } from './board-pick'
+import { ensurePlanPanes } from './ensure-panes'
+import { mainCheckout, worktreeRoot } from './git'
+import { fetchPullRequests } from './github'
+import { runLive } from './live'
+import { parseOptions } from './options'
+import { isSupervisedChild } from './restart-decision'
+import { clockLocaleOf, readSettings } from './settings'
+import { loadSnapshot, type Source } from './snapshot'
+import { superviseView } from './supervisor'
+import { frameText, paneWidth, renderSnapshot, startSelection } from './view'
+
+const printOnce = async (source: Source): Promise<void> => {
+  const snapshot = await loadSnapshot(source, await fetchPullRequests(source.root))
+  const screen = renderSnapshot(
+    snapshot,
+    startSelection(snapshot, source.options),
+    snapshot.errors,
+    paneWidth(),
+    clockLocaleOf(source.settings),
+  )
+  console.log(frameText(screen, Boolean(process.stdout.isTTY)))
+}
+
+/**
+ * `jh plans [<board.md>] [--lane <name>] [--once | --ensure]`: a live view of a board's lanes and their plan
+ * progress; `--ensure` instead brings back the missing views beside the coordinator and each lane.
+ * `home` is where the global config is looked up when the project has none.
+ */
+export const run = async (args: string[], home: string = homedir()): Promise<number> => {
+  try {
+    const options = parseOptions(args)
+    const root = mainCheckout(process.cwd())
+    const settings = readSettings([worktreeRoot(process.cwd()), root], home)
+    const terminal = laneStatusSourceFor(settings.adapter)
+    const picked = boardFor(options.boardPath, [root, worktreeRoot(process.cwd())], settings, () =>
+      foundLanesOf(root, settings, () => terminal.listAgents().map((agent) => agent.name)),
+    )
+    if (options.ensure) {
+      const lines =
+        settings.adapter === TERMINAL_ADAPTER.herdr
+          ? ensurePlanPanes(root, settings, picked.file)
+          : ['the terminal adapter is not herdr: no panes to bring back']
+      for (const line of lines.length > 0 ? lines : ['every plans view is running']) console.log(line)
+      return 0
+    }
+    const source = { root, sprintFile: picked.file, options, settings, terminal, boardNotice: picked.notice }
+    if (options.once || !process.stdout.isTTY) await printOnce(source)
+    else if (isSupervisedChild(process.env)) runLive(source)
+    else return await superviseView(args, await startedKit())
+    return 0
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error))
+    return 1
+  }
+}

package/src/plans/ensure-panes.ts

@@ -0,0 +1,71 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { basename, join } from 'node:path'
+import { defaultCoordinatorName } from '../context/coordinator-name'
+import { parseSprintLanes } from '../plan-format'
+import { parseAgentList, runHerdr } from '../terminal/herdr'
+import { errorText } from './error-text'
+import {
+  agentPanesOf,
+  coordinatorPaneOf,
+  foregroundOf,
+  missingCoordinatorNote,
+  type PaneAction,
+  type PaneState,
+  paneListOf,
+  planPaneActions,
+  splitPaneOf,
+  viewCommandOf,
+  withAgentPanes,
+} from './plan-panes'
+import type { PlansSettings } from './settings'
+
+const panesWithForeground = (agentPanes: readonly string[]): PaneState[] =>
+  withAgentPanes(paneListOf(runHerdr(['pane', 'list'])), agentPanes).map((each) => ({
+    ...each,
+    foreground: foregroundOf(runHerdr(['pane', 'process-info', '--pane', each.pane])),
+  }))
+
+/** The board's lanes that have a worktree, closed ones left out. */
+const lanesOf = (root: string, settings: PlansSettings, boardFile: string) =>
+  parseSprintLanes(readFileSync(boardFile, 'utf8'), settings.planLanguage)
+    .filter((lane) => !lane.closed)
+    .map((lane) => ({ name: lane.name, cwd: join(root, settings.worktreeDirectory, lane.name) }))
+    .filter((lane) => existsSync(lane.cwd))
+
+/** Carries out one action; a failure becomes the action's line, so the other views are still tried. */
+const apply = (action: PaneAction): string => {
+  try {
+    const target =
+      action.kind === 'split'
+        ? splitPaneOf(runHerdr(['pane', 'split', action.pane, '--direction', 'right', '--no-focus']))
+        : action.pane
+    runHerdr(['pane', 'run', target, action.command])
+    return `${action.kind === 'split' ? `split ${action.pane}, ` : ''}started the plans view in ${target}`
+  } catch (error) {
+    return `${action.pane}: ${errorText(error)}`
+  }
+}
+
+/**
+ * `plans --ensure`: brings back every missing plans view beside the coordinator and each lane of the board, and
+ * leaves running ones alone, so it can run after every start. A lane gets its view once its agent runs. One line per
+ * action or skipped target, none when every view runs.
+ */
+export const ensurePlanPanes = (root: string, settings: PlansSettings, boardFile: string): string[] => {
+  const agents = runHerdr(['agent', 'list'])
+  const panes = panesWithForeground(agentPanesOf(agents))
+  const coordinatorName = defaultCoordinatorName(basename(root))
+  const { actions, notes } = planPaneActions({
+    panes,
+    coordinator: coordinatorPaneOf(panes, root, {
+      named: parseAgentList(agents).find((agent) => agent.name === coordinatorName)?.pane ?? null,
+      caller: process.env.HERDR_PANE_ID ?? null,
+    }),
+    lanes: lanesOf(root, settings, boardFile),
+    root,
+    worktrees: join(root, settings.worktreeDirectory),
+    command: (lane) => viewCommandOf(process.argv, lane),
+    missingCoordinator: missingCoordinatorNote(panes, root, coordinatorName),
+  })
+  return [...actions.map(apply), ...notes]
+}

package/src/plans/error-text.ts

@@ -0,0 +1,5 @@
+import { terminalSafe } from '../plan-format/terminal-text'
+
+/** Error text comes from git, gh and the terminal adapter and is printed, so it is made terminal-safe. */
+export const errorText = (error: unknown): string =>
+  terminalSafe(error instanceof Error ? error.message : String(error))

package/src/plans/fetch.ts

@@ -0,0 +1,96 @@
+import { errorText } from './error-text'
+import type { PullRequestState } from './github'
+
+/** The background fetch of the base branch: when it last ran, when it last worked and why it failed. */
+export type FetchState = {
+  lastAttempt: number | null
+  lastSuccess: Date | null
+  failure: string | null
+  running: boolean
+}
+
+export type FetchDecision = {
+  now: number
+  state: Pick<FetchState, 'lastAttempt' | 'running'>
+  intervalMinutes: number
+  /** A pull request of a lane is not open any more: it was merged, or closed. */
+  pullRequestGone: boolean
+}
+
+const MINUTE_MS = 60_000
+const FETCH_TIMEOUT_MS = 60_000
+
+export const initialFetchState = (): FetchState => ({
+  lastAttempt: null,
+  lastSuccess: null,
+  failure: null,
+  running: false,
+})
+
+/** Fetch now: never while one runs or when the interval is 0; at once for a gone pull request, else when the interval has passed. */
+export const shouldFetch = ({ now, state, intervalMinutes, pullRequestGone }: FetchDecision): boolean => {
+  if (intervalMinutes <= 0 || state.running) return false
+  if (pullRequestGone || state.lastAttempt === null) return true
+  return now - state.lastAttempt >= intervalMinutes * MINUTE_MS
+}
+
+/**
+ * The numbers of pull requests of the given lane branches that were open before and are not any more.
+ * Pull requests of other branches are none of the view's business.
+ */
+export const goneLanePullRequests = (
+  previous: PullRequestState['byBranch'],
+  next: PullRequestState['byBranch'],
+  laneBranches: ReadonlySet<string>,
+): number[] => {
+  const stillOpen = new Set([...next.values()].flat().map(({ number }) => number))
+  return [...previous.values()]
+    .flat()
+    .filter(({ branch, number }) => laneBranches.has(branch) && !stillOpen.has(number))
+    .map(({ number }) => number)
+}
+
+/**
+ * The files whose change reloads the view: the plan files, and the main checkout's `FETCH_HEAD`,
+ * which every fetch there rewrites (a linked worktree has its own). So a fetch by another process in
+ * the main checkout (the lane watcher fetches the base branch as soon as it moved) shows at once
+ * instead of on the next refresh, and neither needs the other running.
+ */
+export const watchedFiles = (planFiles: readonly string[], fetchHead: string | null): string[] => [
+  ...planFiles,
+  ...(fetchHead ? [fetchHead] : []),
+]
+
+/** The footer line after a failed fetch; the view carries on with the ref it has. */
+export const fetchNotice = (state: FetchState, baseRef: string, locale: string): string | null => {
+  if (state.failure === null) return null
+  const known = state.lastSuccess
+    ? `last fetch ${state.lastSuccess.toLocaleTimeString(locale)}`
+    : 'not fetched since start'
+  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> => {
+  let timedOut = false
+  let timer: Timer | undefined
+  try {
+    const child = Bun.spawn(['git', '-C', root, 'fetch', '--quiet', remote, branch], {
+      stdout: 'ignore',
+      stderr: 'pipe',
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+    })
+    timer = setTimeout(() => {
+      timedOut = true
+      child.kill()
+    }, FETCH_TIMEOUT_MS)
+    const [stderr, exitCode] = await Promise.all([new Response(child.stderr).text(), child.exited])
+    if (timedOut) return `timed out after ${FETCH_TIMEOUT_MS / 1000} s`
+    if (exitCode === 0) return null
+    return stderr.trim().split('\n')[0] || `git fetch exited with ${exitCode}`
+  } catch (error) {
+    return errorText(error)
+  } finally {
+    clearTimeout(timer)
+  }
+}

package/src/plans/git.ts

@@ -0,0 +1,145 @@
+import { existsSync, readdirSync, statSync } from 'node:fs'
+import { dirname } from 'node:path'
+import type { LaneStatus } from './layout'
+import type { BaseRefInfo } from './sprint-page'
+
+const gitAsync = async (cwd: string, args: string[]): Promise<string | null> => {
+  const child = Bun.spawn(['git', '-C', cwd, ...args], { stdout: 'pipe', stderr: 'ignore' })
+  const [output, exitCode] = await Promise.all([new Response(child.stdout).text(), child.exited])
+  return exitCode === 0 ? output.trim() : null
+}
+
+const git = (cwd: string, args: string[]): string | null => {
+  const result = Bun.spawnSync(['git', '-C', cwd, ...args], { stdout: 'pipe', stderr: 'pipe' })
+  return result.exitCode === 0 ? result.stdout.toString().trim() : null
+}
+
+/** The text of `path` at `ref`, or null when the ref or the file does not exist there. */
+export const showAtRef = (root: string, ref: string, path: string): string | null => {
+  const result = Bun.spawnSync(['git', '-C', root, 'show', `${ref}:${path}`], { stdout: 'pipe', stderr: 'pipe' })
+  return result.exitCode === 0 ? result.stdout.toString() : null
+}
+
+/** The commit `ref` points at, null when it does not exist. */
+export const commitOf = (root: string, ref: string): string | null =>
+  git(root, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`])
+
+/** 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
+
+/**
+ * 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.
+ */
+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
+  return (path) => {
+    const kept = texts.get(path)
+    if (kept !== undefined) return kept
+    const text = showAtRef(root, commit, path)
+    if (text !== null) texts.set(path, text)
+    return text
+  }
+}
+
+export const refExists = (root: string, ref: string): boolean => commitOf(root, ref) !== null
+
+/** Whether `cwd` lies in a linked worktree (`git worktree add`), not in the main checkout; false outside git. */
+export const isLinkedWorktree = (cwd: string): boolean => {
+  const directories = git(cwd, ['rev-parse', '--path-format=absolute', '--git-dir', '--git-common-dir'])?.split('\n')
+  return directories?.length === 2 && directories[0] !== directories[1]
+}
+
+/** The main checkout, also when called from inside a linked worktree. */
+export const mainCheckout = (cwd: string): string => {
+  const commonDirectory = git(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir'])
+  if (!commonDirectory) throw new Error('not inside a git checkout')
+  return dirname(commonDirectory)
+}
+
+/** The top of the checkout `cwd` is in: the worktree itself, not the main checkout. */
+export const worktreeRoot = (cwd: string): string => {
+  const top = git(cwd, ['rev-parse', '--show-toplevel'])
+  if (!top) throw new Error('not inside a git checkout')
+  return top
+}
+
+/**
+ * Branch, commits ahead of `baseRef` and changed files of a worktree; null and 0 when it does not exist. The three
+ * git calls run side by side and without holding the event loop, so a key pressed meanwhile is answered at once.
+ */
+export const gitStatusOf = async (
+  worktree: string,
+  baseRef: string,
+): Promise<Pick<LaneStatus, 'branch' | 'ahead' | 'dirty'>> => {
+  if (!existsSync(worktree)) return { branch: null, ahead: null, dirty: 0 }
+  const [count, porcelain, branch] = await Promise.all([
+    gitAsync(worktree, ['rev-list', '--count', `${baseRef}..HEAD`]),
+    gitAsync(worktree, ['status', '--porcelain']),
+    gitAsync(worktree, ['branch', '--show-current']),
+  ])
+  const ahead = Number.parseInt(count ?? '', 10)
+  return {
+    branch: branch || null,
+    ahead: Number.isNaN(ahead) ? null : ahead,
+    dirty: (porcelain ?? '').split('\n').filter(Boolean).length,
+  }
+}
+
+/** Where this clone keeps `FETCH_HEAD`, whether it exists yet or not; null outside a git checkout. */
+export const fetchHeadPath = (root: string): string | null =>
+  git(root, ['rev-parse', '--path-format=absolute', '--git-path', 'FETCH_HEAD'])
+
+/** The base ref's commit and commit time, and when this clone last fetched (the time of `FETCH_HEAD`), as far as git says. */
+export const baseRefInfo = (root: string, ref: string): BaseRefInfo => {
+  const fetchHead = fetchHeadPath(root)
+  const fetchedAt = fetchHead && existsSync(fetchHead) ? statSync(fetchHead).mtime : null
+  return {
+    name: ref,
+    commit: git(root, ['rev-parse', '--short', `${ref}^{commit}`]),
+    committedAt: git(root, ['log', '-1', '--format=%cI', ref]),
+    fetchedAt,
+  }
+}
+
+const SSH_REMOTE = /^git@([^:]+):(.+?)(?:\.git)?$/
+
+/** The remote as a plain `https://host/path` without credentials, null when it is no http(s) URL. */
+const withoutCredentials = (remote: string): string | null => {
+  try {
+    const url = new URL(remote)
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') return null
+    return `${url.protocol}//${url.host}${url.pathname.replace(/\.git$/, '').replace(/\/$/, '')}`
+  } catch {
+    return null
+  }
+}
+
+/** `https://host/owner/repo/blob/<branch>/` for the `origin` remote, null when there is none or it is no URL we know. */
+export const remoteBlobBase = (root: string, branch: string): string | null => {
+  const remote = git(root, ['remote', 'get-url', 'origin'])
+  if (!remote) return null
+  const ssh = SSH_REMOTE.exec(remote)
+  const base = ssh ? `https://${ssh[1]}/${ssh[2]}` : withoutCredentials(remote)
+  return base ? `${base}/blob/${branch}/` : null
+}
+
+/** The commit time (epoch seconds) of the last commit on `ref` that touched `path`; null when there is none. */
+export const lastCommitTime = (root: string, ref: string, path: string): number | null => {
+  const seconds = Number.parseInt(git(root, ['log', '-1', '--format=%ct', ref, '--', path]) ?? '', 10)
+  return Number.isNaN(seconds) ? null : seconds
+}
+
+/** The names of the directories under the worktree directory; none when it does not exist. */
+export const worktreeNames = (worktreeDirectory: string): string[] =>
+  existsSync(worktreeDirectory)
+    ? readdirSync(worktreeDirectory, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+    : []

package/src/plans/github.ts

@@ -0,0 +1,35 @@
+import { errorText } from './error-text'
+import { PULL_REQUEST_FIELDS, type PullRequest, parsePullRequests, pullRequestsByBranch } from './pull-requests'
+
+/** Open pull requests by head branch, or none with the reason when `gh` fails. */
+export type PullRequestState = { byBranch: Map<string, PullRequest[]>; errors: string[] }
+
+export const noPullRequests = (): PullRequestState => ({ byBranch: new Map(), errors: [] })
+
+/** The GitHub host whose pull request links are trusted; `GH_HOST` names an Enterprise server. */
+export const GITHUB_HOST = process.env.GH_HOST ?? 'github.com'
+
+const runGh = async (root: string): Promise<{ stdout: string; stderr: string; exitCode: number }> => {
+  const child = Bun.spawn(['gh', 'pr', 'list', '--state', 'open', '--limit', '100', '--json', PULL_REQUEST_FIELDS], {
+    cwd: root,
+    stdout: 'pipe',
+    stderr: 'pipe',
+  })
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+    child.exited,
+  ])
+  return { stdout, stderr, exitCode }
+}
+
+/** Open pull requests, or none with the reason; never rejects, also not when `gh` is not installed. */
+export const fetchPullRequests = async (root: string): Promise<PullRequestState> => {
+  try {
+    const { stdout, stderr, exitCode } = await runGh(root)
+    if (exitCode !== 0) throw new Error(`gh pr list: ${stderr.trim() || `exit ${exitCode}`}`)
+    return { byBranch: pullRequestsByBranch(parsePullRequests(stdout, GITHUB_HOST)), errors: [] }
+  } catch (error) {
+    return { byBranch: new Map(), errors: [errorText(error)] }
+  }
+}

package/src/plans/lane-discovery.ts

@@ -0,0 +1,34 @@
+import { terminalSafe } from '../plan-format/terminal-text'
+
+/** What the watcher finds a lane by: the worktree directories, the herdr agent names, the sprint's lane rows. */
+export type LaneSources = {
+  worktrees: readonly string[]
+  agentNames: readonly string[]
+  sprintLanes: readonly string[]
+}
+
+export type LaneSetChange = { added: string[]; removed: string[] }
+
+/**
+ * The lanes to watch when none are named: a worktree directory whose name a herdr agent carries or
+ * the board's lanes table lists. A worktree with neither (a branch parked in its own checkout) is no
+ * lane, and an agent or a row without a worktree is none either.
+ */
+export const discoverLanes = ({ worktrees, agentNames, sprintLanes }: LaneSources): string[] => {
+  const claimed = new Set([...agentNames, ...sprintLanes])
+  return [...new Set(worktrees)].filter((worktree) => claimed.has(worktree)).sort()
+}
+
+/** The lanes that joined and left between two discoveries, each sorted. */
+export const laneSetChange = (previous: readonly string[], next: readonly string[]): LaneSetChange => ({
+  added: next.filter((lane) => !previous.includes(lane)).sort(),
+  removed: previous.filter((lane) => !next.includes(lane)).sort(),
+})
+
+export const isUnchanged = ({ added, removed }: LaneSetChange): boolean => added.length === 0 && removed.length === 0
+
+/** `lane added: <name>` and `lane removed: <name>`, one line per lane. */
+export const laneSetLines = ({ added, removed }: LaneSetChange): string[] => [
+  ...added.map((lane) => `lane added: ${terminalSafe(lane)}`),
+  ...removed.map((lane) => `lane removed: ${terminalSafe(lane)}`),
+]

package/src/plans/lane-plans.ts

@@ -0,0 +1,80 @@
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { type PlansByHref, parsePlanPhases, resolvePlanPath, type SprintLane } from '../plan-format'
+import type { BaseReader } from './git'
+import { hasOwnWork, mergePlanPhases } from './phase-source'
+import type { PlansSettings } from './settings'
+
+/** Paths that could not be read at the base ref and were read from a checkout instead. */
+export type Fallbacks = string[]
+
+export type LaneWork = { worktree: string | null; ahead: number | null; dirty: number }
+
+/** 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 }
+
+const isOutsideRepository = (path: string): boolean => path.startsWith('..')
+
+/** The file as the base ref has it; null when the ref lacks it or the path leaves the repository. */
+export const textAtBase = (base: BaseReader, path: string): string | null =>
+  isOutsideRepository(path) ? null : base(path)
+
+/** The checkout's copy of a file the base ref lacks, noted in `fallbacks`; null when the checkout lacks it too. */
+export const readFallback = async (
+  path: string,
+  fallbackFile: string,
+  fallbacks: Fallbacks,
+): Promise<string | null> => {
+  if (!existsSync(fallbackFile)) return null
+  fallbacks.push(path)
+  return Bun.file(fallbackFile).text()
+}
+
+/**
+ * The text of a repository file as the base ref has it. A file the ref does not have (new, so only in a
+ * checkout) is read from `fallbackFile` and noted in `fallbacks`; null when it is nowhere.
+ */
+export const readAtBase = async (
+  base: BaseReader,
+  path: string,
+  fallbackFile: string,
+  fallbacks: Fallbacks,
+): Promise<string | null> => textAtBase(base, path) ?? readFallback(path, fallbackFile, fallbacks)
+
+/** The lane's worktree, null when it is missing, with the work the lane has there by its git status. */
+export const laneWorkOf = (worktree: string, status: { ahead: number | null; dirty: number }): LaneWork => ({
+  worktree: existsSync(worktree) ? worktree : null,
+  ahead: status.ahead,
+  dirty: status.dirty,
+})
+
+/**
+ * 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.
+ */
+export const readPlans = async (lane: SprintLane, sources: PlanSources, work: LaneWork, fallbacks: Fallbacks) => {
+  const { root, settings, sprintDirectory } = sources
+  const plans: PlansByHref = {}
+  const files: string[] = []
+  const texts: Record<string, string> = {}
+  for (const href of new Set(lane.steps.flatMap((step) => (step.planHref ? [step.planHref] : [])))) {
+    const path = resolvePlanPath(sprintDirectory, href)
+    const worktreeFile = work.worktree ? join(work.worktree, path) : null
+    const file = worktreeFile && existsSync(worktreeFile) ? worktreeFile : join(root, path)
+    const text = await readAtBase(sources.base, path, file, fallbacks)
+    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,
+    )
+    files.push(file)
+    texts[href] = text
+  }
+  return { plans, files, texts }
+}