jackherd 1.16.0 → 1.17.0

package/src/plans/github.ts

@@ -4,31 +4,40 @@ import { PULL_REQUEST_FIELDS, type PullRequest, parsePullRequests, pullRequestsB
 /** Open pull requests by head branch, or none with the reason when `gh` fails. */
 export type PullRequestState = { byBranch: Map<string, PullRequest[]>; errors: string[] }
 
+/** What `gh` answered: stdout on success, else the reason. */
+export type GhAnswer = { ok: true; stdout: string } | { ok: false; reason: 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 runGh = async (args: readonly string[], root: string): Promise<GhAnswer> => {
+  const child = Bun.spawn(['gh', ...args], { 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 }
+  return exitCode === 0 ? { ok: true, stdout } : { ok: false, reason: stderr.trim() || `exit ${exitCode}` }
+}
+
+/** Runs `gh`; never rejects, also not when `gh` is not installed, and the reason is terminal-safe. */
+const askGh = async (args: readonly string[], root: string): Promise<GhAnswer> => {
+  try {
+    const answer = await runGh(args, root)
+    return answer.ok ? answer : { ok: false, reason: errorText(answer.reason) }
+  } catch (error) {
+    return { ok: false, reason: errorText(error) }
+  }
 }
 
 /** 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> => {
+  const answer = await askGh(['pr', 'list', '--state', 'open', '--limit', '100', '--json', PULL_REQUEST_FIELDS], root)
+  if (!answer.ok) return { byBranch: new Map(), errors: [`gh pr list: ${answer.reason}`] }
   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: [] }
+    return { byBranch: pullRequestsByBranch(parsePullRequests(answer.stdout, GITHUB_HOST)), errors: [] }
   } catch (error) {
     return { byBranch: new Map(), errors: [errorText(error)] }
   }

package/src/plans/layout.ts

@@ -81,8 +81,10 @@ import {
 import {
   BACKLOG_KEY,
   type ClickTarget,
+  entryBlockHeadKey,
   isBlockFolded,
   isBlockHeadKey,
+  isEntryBlockFolded,
   isLaneOpen,
   isLanesOpen,
   LANES_KEY,
@@ -239,18 +241,23 @@ type TopBlock = {
   hidden: number
   expanded: boolean
   rows: BlockRow[]
-  /** The mark in front of the name in place of the chevron, for a block that does not fold; absent for the chevron. */
-  headMark?: string
 }
 
 /** What the head of a block says: its name, its count, its balance and the paint of the count. */
-type BlockHeadParts = Pick<TopBlock, 'name' | 'count' | 'balance' | 'countPaint' | 'headMark'>
+type BlockHeadParts = Pick<TopBlock, 'name' | 'count' | 'balance' | 'countPaint'>
 
 /** The blocks on top of the herd one under the other: their lines below the title, and the hit of each drawn block. */
 type BlockStack = { lines: string[]; hits: (BlockHit | null)[] }
 
 /** What every lane of the lanes block is drawn with. */
-type LanesContext = { state: Selection; width: number; badgeTexts: BadgeTexts; taskStyle: TaskStyle }
+type LanesContext = {
+  state: Selection
+  width: number
+  badgeTexts: BadgeTexts
+  taskStyle: TaskStyle
+  /** How a lane's `↳` activity line is drawn: shimmering while the herd does, so its task rests, dim otherwise. */
+  activityStyle: TaskStyle
+}
 
 /** In front of every line of the lanes block under its head. */
 const LANE_INDENT = '  '
@@ -782,6 +789,14 @@ const detailPlacement = (
   return { beside, room: beside ? besideRoom : width - visibleLength(indent) }
 }
 
+/**
+ * Whether the whole head and a detail still stand on one line with `right`. A lane that rests has no bar, only the
+ * padding that aligns its badges with the others; `laneLines` gives that back before it cuts the name.
+ */
+const detailFitsBeside = (head: string, right: string, width: number, indent: string): boolean =>
+  visibleLength(head) + COLUMN_SEPARATOR.length + visibleLength(right) < width &&
+  detailPlacement(head, right, width, indent).beside
+
 /** The summary the snapshot read for the lane, or the one its own steps give. */
 const summaryOf = (view: LaneView): LaneSummary =>
   view.summary ?? laneSummary({ progress: view.progress, phases: {}, activity: {} }, 0)
@@ -805,16 +820,23 @@ const laneRight = (view: LaneView, tallyWidth: number): string => {
 /** The cells of the phase count column, 0 when the pane leaves it out. */
 const tallyWidthOf = ({ phases, tally }: LaneColumns): number => (phases ? tally : 0)
 
-/** A folded lane's marks in the column of `columns.marks`, right before context and bar. */
-const markedRight = (view: LaneView, columns: LaneColumns): string => {
+/** The marks in the column of `columns.marks`, `padOf(right)` cells before the lane's own context and bar. */
+const marksBeforeRight = (view: LaneView, columns: LaneColumns, padOf: (right: string) => number): string => {
   const right = laneRight(view, tallyWidthOf(columns))
   const marks = laneMarks(view)
   if (!marks) return right
   if (columns.right === 0) return padVisible(marks, columns.marks)
-  const pad = ' '.repeat(Math.max(columns.right - visibleLength(right), 0))
-  return `${padVisible(marks, columns.marks)}${COLUMN_SEPARATOR}${pad}${right}`
+  return `${padVisible(marks, columns.marks)}${COLUMN_SEPARATOR}${' '.repeat(padOf(right))}${right}`
 }
 
+/** A folded lane's marks right before context and bar, padded to the widest right column of the pane. */
+const markedRight = (view: LaneView, columns: LaneColumns): string =>
+  marksBeforeRight(view, columns, (right) => Math.max(columns.right - visibleLength(right), 0))
+
+/** `markedRight` without the padding a lane without a bar only has to align its marks with the other lanes'. */
+const markedRightTight = (view: LaneView, columns: LaneColumns): string =>
+  marksBeforeRight(view, columns, (right) => (right ? Math.max(columns.right - visibleLength(right), 0) : 0))
+
 /** The task row below a folded lane's phase row, under the lane's name; none while the lane reports no task. */
 const foldedTaskRow = (view: LaneView, indent: string, width: number, style: TaskStyle): string[] => {
   const phase = headPhase(view)
@@ -839,8 +861,9 @@ const laneLines = (
   const nameStyle = restsFolded(view, open) ? paint.dim : paint.bold
   const cells = padVisible(nameStyle(fit(progress.lane.name, columns.name)), columns.name)
   const head = `${paint.dim(chevronOf(open))} ${symbolCell(status.agent)} ${cells}`
-  const right = open ? laneProgressColumn(view, tallyWidthOf(columns)) : markedRight(view, columns)
   const nameIndent = ' '.repeat(visibleLength(head) - visibleLength(cells))
+  const aligned = open ? laneProgressColumn(view, tallyWidthOf(columns)) : markedRight(view, columns)
+  const right = open || detailFitsBeside(head, aligned, width, nameIndent) ? aligned : markedRightTight(view, columns)
   const { room } = detailPlacement(head, right, width, nameIndent)
   const lines = withDetail(head, laneDetail(view, open, reason, room), right, width, nameIndent)
   return open ? lines : [...lines, ...foldedTaskRow(view, nameIndent, width, taskStyle)]
@@ -935,7 +958,7 @@ const activityFrame = (
   key: string,
   indent: string,
   text: string,
-  { state, width }: { state: Selection; width: number },
+  { state, width, style }: { state: Selection; width: number; style: TaskStyle },
 ): Frame => {
   const head = `${indent}${ACTIVITY_MARK} `
   const cut = textWidth(`${head}${text}`) > width
@@ -945,44 +968,69 @@ const activityFrame = (
           index === 0 ? `${head}${line}` : `${' '.repeat(textWidth(head))}${line}`,
         )
       : [fit(`${head}${text}`, width)]
-  const dimmed = lines.map((line) => paint.dim(line))
-  return cut ? rowFrame(key, dimmed, [], { state, width }) : textFrame(dimmed)
+  const styled = lines.map(style)
+  return cut ? rowFrame(key, styled, [], { state, width }) : textFrame(styled)
 }
 
 /**
  * The last action of a working lane's agent and of each of its running subagents, one dim line each, under the lane
- * line in the column of its children. None while the lane does not work, or without a source for it.
+ * line in the column of its children. None while the lane does not work, or without a source for it. The first
+ * subagent line shimmers when nothing else of the lane does (`leadsSubagent`).
  */
 const activityFrames = (
   { activity, status, progress }: LaneView,
-  context: { state: Selection; width: number },
+  {
+    activityStyle,
+    leadsSubagent,
+    ...context
+  }: Pick<LanesContext, 'state' | 'width' | 'activityStyle'> & {
+    leadsSubagent: boolean
+  },
 ): Frame[] => {
   if (!activity || status.agent !== AGENT_STATUS.working) return []
   const lane = progress.lane.name
   const indent = ' '.repeat(LANE_HEAD_CELLS)
+  const still = { ...context, style: paint.dim }
   return [
-    ...(activity.lane === null ? [] : [activityFrame(laneActivityKey(lane), indent, activity.lane, context)]),
-    ...activity.subagents.map(({ label, description, line }) =>
+    ...(activity.lane === null
+      ? []
+      : [activityFrame(laneActivityKey(lane), indent, activity.lane, { ...context, style: activityStyle })]),
+    ...activity.subagents.map(({ label, description, line }, index) =>
       activityFrame(
         subagentActivityKey(lane, label),
         `${indent}${SUBAGENT_ACTIVITY_INDENT}`,
         `${ellipsize(description ?? label, SUBAGENT_NAME_CELLS)}: ${line}`,
-        context,
+        leadsSubagent && index === 0 ? { ...context, style: activityStyle } : still,
       ),
     ),
   ]
 }
 
+/** True when the lane shows its own `↳` activity line: the one line of the lane that shimmers, its task rests. */
+const showsLaneActivity = ({ activity, status }: LaneView): boolean =>
+  typeof activity?.lane === 'string' && status.agent === AGENT_STATUS.working
+
+/** True when a task line of the lane shimmers: the pane shimmers its tasks and the lane reports one to show. */
+const showsShimmeringTask = (
+  view: LaneView,
+  { width, taskStyle }: Pick<LanesContext, 'width' | 'taskStyle'>,
+): boolean => taskStyle === SHIMMERING_TASK && foldedTaskRow(view, '', width, taskStyle).length > 0
+
+/** True when no line of the lane shimmers yet, so its first subagent line does: neither its activity nor its task. */
+const subagentLeads = (view: LaneView, context: Pick<LanesContext, 'width' | 'taskStyle'>): boolean =>
+  !showsLaneActivity(view) && !showsShimmeringTask(view, context)
+
 /**
  * The lane line is a row of its own; an open lane continues after a blank line with its session, links, pull requests
  * and phases (`openLaneFrame`), indented to the column of the lane's name.
  */
 const laneBlock = (
   view: LaneView,
-  { state, width, badgeTexts, taskStyle }: LanesContext,
+  { state, width, badgeTexts, taskStyle: lanesTaskStyle, activityStyle }: LanesContext,
   columns: LaneColumns,
   reason: LaneReason | null,
 ): Frame => {
+  const taskStyle = showsLaneActivity(view) ? STILL_TASK : lanesTaskStyle
   const context: LaneContext = {
     progress: view.progress,
     state,
@@ -997,7 +1045,8 @@ const laneBlock = (
   const open = isLaneOpen(state, view.progress.lane.name, view.status.agent)
   const lines = laneLines(view, open, { width, taskStyle }, columns, reason)
   const lane = rowFrame(laneKey(view.progress.lane.name), lines, [], context)
-  const row = joinFrames([lane, ...activityFrames(view, { state, width })])
+  const leadsSubagent = subagentLeads(view, { width, taskStyle: lanesTaskStyle })
+  const row = joinFrames([lane, ...activityFrames(view, { state, width, activityStyle, leadsSubagent })])
   if (!open) return row
   const inner = narrower(context, LANE_HEAD_CELLS)
   const head = {
@@ -1131,13 +1180,9 @@ const blockBar = (): string => ' '
  * above the block; `▸ <name> · <n>  <balance>` while folded. The count (in `countPaint` while it is more than 0) is
  * left out for a block without one; the balance comes painted.
  */
-const blockHead = (
-  { name, count, balance, countPaint, headMark }: BlockHeadParts,
-  open: boolean,
-  width: number,
-): string => {
+const blockHead = ({ name, count, balance, countPaint }: BlockHeadParts, open: boolean, width: number): string => {
   const counted = count === null ? '' : ` ${ITEM_SEPARATOR} ${count > 0 ? countPaint(String(count)) : count}`
-  const lead = `${paint.dim(headMark ?? chevronOf(open))} ${name}${counted}${balance ? `  ${balance}` : ''}`
+  const lead = `${paint.dim(chevronOf(open))} ${name}${counted}${balance ? `  ${balance}` : ''}`
   if (!open) return fit(lead, width)
   const cut = fit(lead, Math.max(width - 2, 1))
   return `${cut} ${paint.dim(RULE.repeat(Math.max(width - visibleLength(cut) - 1, 0)))}`
@@ -1334,9 +1379,9 @@ const entryRowShares = (counts: readonly number[], budget: number): number[] =>
 type EntryBlock = { source: HerdSource; now: number; share: number }
 
 /**
- * The block of a source that shows its entries: always open, headed by its label (else its name) without a chevron,
- * its `share` of entries and `+<n>` for the rest, which opens all of them and folds them again as in the other blocks.
- * The head is no click target; an entry with an address opens it.
+ * The block of a source that shows its entries: open at the start, headed by its label (else its name) and the number
+ * of entries, folded and opened again by its head as in the other blocks, its `share` of entries and `+<n>` for the
+ * rest, which opens all of them and folds them again. An entry with an address opens it.
  */
 const entryBlockLines = ({ source, now, share }: EntryBlock, state: Selection, width: number): BlockLines => {
   const moreKey = sourceMoreKey(source.name)
@@ -1344,7 +1389,7 @@ const entryBlockLines = ({ source, now, share }: EntryBlock, state: Selection, w
   const hidden = source.entries.length - share
   const block: TopBlock = {
     name: source.label ?? source.name,
-    count: null,
+    count: source.entries.length,
     balance: '',
     markPaint: paint.dim,
     focused: (key) => isFocused(state, key),
@@ -1354,10 +1399,11 @@ const entryBlockLines = ({ source, now, share }: EntryBlock, state: Selection, w
     hidden,
     expanded,
     rows: allBlockRows(entryBlockItems(source, now, expanded ? source.entries.length : share), new Set(), width),
-    headMark: ' ',
   }
-  const { lines, hit } = openBlockLines(block, '', width)
-  return { open: true, lines, hit: { rows: hit.rows, moreKey: hit.moreKey } }
+  const headKey = entryBlockHeadKey(source.name)
+  return isEntryBlockFolded(state, source.name)
+    ? foldedBlockLines(block, headKey, width)
+    : openBlockLines(block, headKey, width)
 }
 
 const entryBlocksOf = (sourceBlock: SourceBlock | undefined, state: Selection, width: number): BlockLines[] => {
@@ -1533,6 +1579,7 @@ export const renderScreen = (
   width: number,
 ): Screen => {
   const taskStyle = shimmer ? SHIMMERING_TASK : STILL_TASK
+  const activityStyle = shimmer ? SHIMMERING_TASK : paint.dim
   const { active, waiting, noAgent } = partitionLanes(lanes)
   const badgeTexts = BADGE_TEXTS
   const turnRowsOf = yourTurn ? [...yourTurn.turn.now, ...yourTurn.turn.planned] : []
@@ -1547,7 +1594,9 @@ export const renderScreen = (
   const stack = stackBlocks([turn, ...entryBlocks, listed], above.length)
   const sourcesSlot = 1 + entryBlocks.length
   const sections = [
-    ...(active.length > 0 ? [lanesFrame(active, turnRowsOf, { state, width, badgeTexts, taskStyle })] : []),
+    ...(active.length > 0
+      ? [lanesFrame(active, turnRowsOf, { state, width, badgeTexts, taskStyle, activityStyle })]
+      : []),
     ...(waiting.length > 0 ? [waitingFrame(waiting, state, width)] : []),
     textFrame(parkedBlock(noAgent, width)),
     ...(planned.length > 0 ? [backlogFrame(planned, state, width)] : []),

package/src/plans/live.ts

@@ -47,10 +47,7 @@ import {
   parseMouse,
   splitKeys,
   syncLaneFolds,
-  TOP_BLOCK,
-  type TopBlockId,
   toggledExpansion,
-  topBlockHeadKey,
   type View,
   windowTop,
   withoutStaleMotions,
@@ -527,18 +524,18 @@ const applyBlockClick = (live: Live, outcome: BlockClick): void => {
 }
 
 /**
- * A plain click on a block on top of the herd, matched against `hit` as it was drawn: the head of `block` folds or
- * opens it (a block of entries, `block` null, has no such head), a
+ * A plain click on a block on top of the herd, matched against `hit` as it was drawn: the head folds or
+ * opens its block, a
  * cut-off row expands, a file or Artifact opens, a button asks the coordinator or closes the row; the failure or the
  * result shows in the footer.
  */
-const clickBlock = (live: Live, block: TopBlockId | null, hit: BlockHit | null, input: string): boolean => {
+const clickBlock = (live: Live, hit: BlockHit | null, input: string): boolean => {
   const mouse = parseMouse(input)
   if (!mouse || !hit) return false
-  if (block !== null && blockHeadClick(hit.firstLine - 1, mouse)) {
+  if (hit.headKey && blockHeadClick(hit.firstLine - 1, mouse)) {
     live.view = {
       ...live.view,
-      selection: applyClick(live.view.selection, topBlockHeadKey(block)),
+      selection: applyClick(live.view.selection, hit.headKey),
     }
     return true
   }
@@ -588,7 +585,6 @@ const handleInput = (live: Live, input: string) => {
     hover(live, screen, mouse)
     return
   }
-  live.notice = null
   const settled = settledSelection(live.view.selection, screen)
   live.view = { ...live.view, selection: mouse ? settled : withoutHover(settled) }
   if (activateBlockRow(live, screen, input)) {
@@ -600,9 +596,9 @@ const handleInput = (live: Live, input: string) => {
     return
   }
   if (
-    clickBlock(live, TOP_BLOCK.yourTurn, screen.yourTurnBlock, input) ||
-    screen.entryBlocks.some((hit) => clickBlock(live, null, hit, input)) ||
-    clickBlock(live, TOP_BLOCK.sources, screen.sourceBlock, input)
+    clickBlock(live, screen.yourTurnBlock, input) ||
+    screen.entryBlocks.some((hit) => clickBlock(live, hit, input)) ||
+    clickBlock(live, screen.sourceBlock, input)
   ) {
     redraw(live)
     return

package/src/plans/plan-panes.ts

@@ -35,6 +35,14 @@ export type PlanPaneResult = { actions: PaneAction[]; notes: string[] }
 
 type ListedPane = { pane_id: string; tab_id: string; cwd: string; agent?: unknown; label?: unknown }
 
+/**
+ * The exit codes of `herd --ensure`: `noCoordinator` when the coordinator's pane is missing or ambiguous, so a
+ * caller that runs it after a restart knows to wait for the coordinator's session; 1 stays the error of the CLI.
+ */
+export const ENSURE_EXIT = { done: 0, noCoordinator: 3 } as const
+
+export type EnsureExit = (typeof ENSURE_EXIT)[keyof typeof ENSURE_EXIT]
+
 const isListedPane = (value: unknown): value is ListedPane => {
   if (typeof value !== 'object' || value === null) return false
   const candidate = value as Record<string, unknown>
@@ -124,9 +132,13 @@ export const isIdleShell = ({ agent, foreground }: PaneState): boolean =>
 const isStartingShell = ({ agent, foreground }: PaneState): boolean =>
   !agent && (foreground.length === 0 || SHELLS.has(programOf(foreground[0])))
 
+const hasHerdBeside = (panes: readonly PaneState[], agent: PaneState): boolean =>
+  panes.some((each) => each.tab === agent.tab && each.label === herdLabel(null))
+
 /**
  * The coordinator's pane: the agent herdr lists under the coordinator's name, else the calling pane when an agent
- * in the main checkout runs there, else the only agent in the main checkout. Two agents there and no name: none.
+ * in the main checkout runs there, else the only agent in the main checkout, else the only one there whose tab holds
+ * a pane labelled `herd` (herdr keeps labels across a restart, agent names not always). Otherwise none.
  */
 export const coordinatorPaneOf = (
   panes: readonly PaneState[],
@@ -136,15 +148,20 @@ export const coordinatorPaneOf = (
   if (hints.named) return hints.named
   const inRoot = panes.filter((each) => each.agent && each.cwd === root)
   if (hints.caller && inRoot.some((each) => each.pane === hints.caller)) return hints.caller
-  return inRoot.length === 1 ? (inRoot[0]?.pane ?? null) : null
+  const candidates = inRoot.length === 1 ? inRoot : inRoot.filter((agent) => hasHerdBeside(panes, agent))
+  return candidates.length === 1 ? (candidates[0]?.pane ?? null) : null
 }
 
-/** Why no coordinator pane was found: no agent in the main checkout, or several and none of them named. */
+/** The exit code of `herd --ensure` for the coordinator pane it found among `panes`, or none. */
+export const ensureExitOf = (panes: readonly PaneState[], coordinator: string | null): EnsureExit =>
+  panes.some((each) => each.pane === coordinator) ? ENSURE_EXIT.done : ENSURE_EXIT.noCoordinator
+
+/** Why no coordinator pane was found: no agent in the main checkout, or several, none named and none alone beside a herd pane. */
 export const missingCoordinatorNote = (panes: readonly PaneState[], root: string, name: string): string => {
   const inRoot = panes.filter((each) => each.agent && each.cwd === root).length
   return inRoot === 0
     ? 'coordinator: no agent in the main checkout'
-    : `coordinator: ${inRoot} agents in the main checkout and none named ${name}; run herd --ensure in its pane, or herdr agent rename <pane> ${name}`
+    : `coordinator: ${inRoot} agents in the main checkout, none named ${name} and none alone beside a herd pane; run herd --ensure in its pane, or herdr agent rename <pane> ${name}`
 }
 
 const quoted = (arg: string): string => (/^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'\\''`)}'`)

package/src/plans/selection.ts

@@ -27,6 +27,8 @@ export type Selection = {
   laneFolds: ReadonlyMap<string, LaneFold>
   /** The top blocks the user opened; every other one is folded, at the start of the herd all of them. */
   openBlocks?: ReadonlySet<TopBlockId>
+  /** The sources whose block of entries the user folded; absent or without the source while it is open, as at the start. */
+  foldedEntryBlocks?: ReadonlySet<string>
   /** True once the user folded the lanes block, which is open at the start; absent or false while it is open. */
   lanesFolded?: boolean
 }
@@ -110,6 +112,26 @@ export const topBlockHeadKey = (block: TopBlockId): string => `${TOP_HEAD_KEY_PR
 export const topBlockOfKey = (key: string): TopBlockId | null =>
   Object.values(TOP_BLOCK).find((block) => topBlockHeadKey(block) === key) ?? null
 
+const ENTRY_HEAD_KEY_PREFIX = `${TOP_HEAD_KEY_PREFIX}entries>`
+
+/** The key of the head of the block of entries of a source, which the arrows reach like every other clickable row. */
+export const entryBlockHeadKey = (source: string): string => `${ENTRY_HEAD_KEY_PREFIX}${source}`
+
+/** The source whose block of entries a head key names, null for any other key. */
+export const entryBlockOfKey = (key: string): string | null =>
+  key.startsWith(ENTRY_HEAD_KEY_PREFIX) ? key.slice(ENTRY_HEAD_KEY_PREFIX.length) : null
+
+/** Whether the block of entries of `source` is drawn folded: it is open at the start, until the user folds it. */
+export const isEntryBlockFolded = ({ foldedEntryBlocks }: Selection, source: string): boolean =>
+  foldedEntryBlocks?.has(source) === true
+
+const withEntryBlockOpen = (selection: Selection, source: string, open: boolean): Selection => {
+  const folded = new Set(selection.foldedEntryBlocks)
+  if (open) folded.delete(source)
+  else folded.add(source)
+  return { ...selection, foldedEntryBlocks: folded }
+}
+
 /** Whether the lanes block is drawn open: it is at the start of the herd, until the user folds it. */
 export const isLanesOpen = ({ lanesFolded }: Selection): boolean => !lanesFolded
 
@@ -274,6 +296,13 @@ const foldedHead = (selection: Selection, key: string, next: (open: boolean) =>
   const lane = laneOfKey(key)
   if (lane !== null) return { ...foldLane(selection, lane, next), selected: key }
   if (key === LANES_KEY) return { ...withLanesOpen(selection, next(isLanesOpen(selection))), selected: key }
+  const entrySource = entryBlockOfKey(key)
+  if (entrySource !== null) {
+    return {
+      ...withEntryBlockOpen(selection, entrySource, next(!isEntryBlockFolded(selection, entrySource))),
+      selected: key,
+    }
+  }
   const block = topBlockOfKey(key)
   if (block === null) return null
   return { ...withBlockOpen(selection, block, next(!isBlockFolded(selection, block))), selected: key }

package/src/plans/settings.ts

@@ -4,6 +4,7 @@ import { type JackherdConfig, parseJackherdConfig } from '../config'
 import { PROJECT_CONFIG_PATH } from '../config/location'
 import { readConfig } from '../config/read-config'
 import type { ToneName } from '../config/tones'
+import { DEFAULT_MIN_FREE_GB } from '../lane/space'
 import type { TicketSource } from '../watch/plan-badges'
 import type { SourceShow } from '../watch/sources'
 import { type WatchedSource, watchedSourceOf } from '../watch/watched-source'
@@ -15,6 +16,8 @@ export type PlansSettings = Pick<
   'planDirectory' | 'board' | 'worktreeDirectory' | 'baseBranch' | 'planLanguage' | 'responseLanguage' | 'skillPrefix'
 > & {
   adapter: JackherdConfig['terminal']['adapter']
+  /** Free gigabytes a new lane needs on the disk (`lanes.minFreeGb`). */
+  minFreeGb: number
   fetchIntervalMinutes: number
   /** Whether the running task of a folded lane shimmers; `NO_COLOR` keeps it still whatever this says. */
   shimmer: boolean
@@ -58,6 +61,7 @@ export const plansSettingsOf = (config: JackherdConfig): PlansSettings => ({
   responseLanguage: config.responseLanguage,
   skillPrefix: config.skillPrefix,
   adapter: config.terminal.adapter,
+  minFreeGb: config.lanes.minFreeGb ?? DEFAULT_MIN_FREE_GB,
   fetchIntervalMinutes: config.plans.fetchIntervalMinutes,
   shimmer: config.plans.shimmer,
   linkKinds: config.plans.linkKinds,