jackherd 1.16.0 → 1.18.0

package/src/plan-contract/command.ts

@@ -3,22 +3,29 @@ import { homedir } from 'node:os'
 import { resolve } from 'node:path'
 import { findProjectRoot } from '../config/location'
 import { readConfig } from '../config/read-config'
+import { installedReferenceHint } from '../lane/skill-hint'
 import { asksForHelp } from '../preview/options'
 import { CLI_NAME } from '../version/release'
 import type { PlanLanguage } from '../vocabulary'
+import { REFERENCE, type Reference, referenceLine } from '../watch/reference-paths'
+import { baseGapLinesFor } from './base-check-git'
 import { contractOf, type PartFinding, type PlanContract } from './contract'
 
 const CHECK_SUBCOMMAND = 'check'
 
-/** Exit codes of `jh plan check`: the contract is met, a part has a gap, the command line or the file is wrong. */
-export const PLAN_CHECK_EXIT = { met: 0, gaps: 1, error: 2 } as const
+/**
+ * Exit codes of `jh plan check`: the contract is met, a part has a gap, the command line or the file is wrong, the
+ * contract is met but the plan or a board that links it is not on the base branch.
+ */
+export const PLAN_CHECK_EXIT = { met: 0, gaps: 1, error: 2, notOnBase: 3 } as const
 
 export const USAGE = `usage: ${CLI_NAME} plan ${CHECK_SUBCOMMAND} <plan.md>
 
 Checks one plan against the plan contract: phases, tasks in every phase, a model for every phase, a dependency
 row for every phase (from two phases on). One line per part, \`file:line\` where a part is incomplete.
+Where git has the base branch, a plan, or a board that links it, that the base branch lacks gets a \`base:\` line with its path.
 The plan language comes from .jackherd/config.json.
-Exit 0 met, 1 with gaps, 2 for a wrong command line or an unreadable file.`
+Exit 0 met, 1 with gaps, 2 for a wrong command line or an unreadable file, 3 met but not on the base branch.`
 
 const where = (file: string, line: number | null): string => (line === null ? '' : ` ${file}:${line}`)
 
@@ -45,6 +52,12 @@ const readPlan = (file: string): string | null => {
   }
 }
 
+/** The line after the findings that names the reference to read for the gap, for exit 1 and exit 3; none without the skill. */
+const printReference = (reference: Reference, home: string): void => {
+  const root = findProjectRoot(process.cwd(), home, existsSync) ?? process.cwd()
+  for (const line of referenceLine(installedReferenceHint(root, reference, home))) console.log(line)
+}
+
 const fail = (message: string): number => {
   console.error(message)
   return PLAN_CHECK_EXIT.error
@@ -65,5 +78,13 @@ export const run = (args: string[], home: string = homedir()): number => {
   if ('error' in result) return fail(result.error)
   const contract = contractOf(markdown, result.language)
   for (const line of contractLines(file, contract)) console.log(line)
-  return contract.met ? PLAN_CHECK_EXIT.met : PLAN_CHECK_EXIT.gaps
+  if (!contract.met) {
+    printReference(REFERENCE.adoptPlan, home)
+    return PLAN_CHECK_EXIT.gaps
+  }
+  const gapLines = baseGapLinesFor(file, process.cwd())
+  for (const line of gapLines) console.log(line)
+  if (gapLines.length === 0) return PLAN_CHECK_EXIT.met
+  printReference(REFERENCE.planCommit, home)
+  return PLAN_CHECK_EXIT.notOnBase
 }

package/src/plan-format/plan-structure.ts

@@ -20,11 +20,11 @@ export type PhaseWithoutGate = PhaseHeading
 /** A row of the lanes table (1-based line) whose phases cell names no phase id. */
 export type RowWithoutPhase = OpenLaneRow
 
-/**
- * A `### Phase` heading (1-based line) whose tasks are all ticked on the base branch while its own section still
- * has open checkboxes not moved on with `→ P<n>` (`openLines`, 1-based).
- */
-export type MergedPhaseWithOpenBoxes = PhaseWithoutGate & { openLines: number[] }
+/** A `### Phase` heading (1-based line) whose own section has open checkboxes not moved on with `→ P<n>` (`openLines`, 1-based). */
+export type PhaseWithOpenBoxes = PhaseWithoutGate & { openLines: number[] }
+
+/** A `PhaseWithOpenBoxes` whose tasks are all ticked on the base branch. */
+export type MergedPhaseWithOpenBoxes = PhaseWithOpenBoxes
 
 type PhaseSection = PhaseWithoutGate & { tasks: boolean; gate: boolean; openLines: number[] }
 
@@ -118,6 +118,18 @@ export const mergedPhasesWithOpenBoxes = (
     .map(({ line, id, title, openLines }) => ({ line, id, title, openLines }))
 }
 
+/**
+ * The phase `id` of `markdown` when its own section still has open checkboxes, gate boxes included, that no `→ P<n>`
+ * at their end moves on; null when it has none or the plan lacks the phase. Unlike `mergedPhasesWithOpenBoxes` it
+ * does not ask whether the phase counts as merged: the caller knows which phase a branch builds.
+ */
+export const openBoxesOfPhase = (markdown: string, language: PlanLanguage, id: string): PhaseWithOpenBoxes | null => {
+  const section = phaseSections(markdown, language).find((candidate) => candidate.id === id)
+  return section && section.openLines.length > 0
+    ? { line: section.line, id: section.id, title: section.title, openLines: section.openLines }
+    : null
+}
+
 /**
  * The changed rows of open lanes whose phases cell names no phase id (`P10c`), so neither the view nor the watcher
  * can tie that step to a phase.

package/src/plans/ask-coordinator.ts

@@ -1,8 +1,10 @@
 import { TERMINAL_ADAPTER, type TerminalAdapter } from '../config'
 import { resolveCoordinatorName } from '../context/coordinator-name'
+import { installedReferenceHintFor } from '../lane/skill-hint'
 import { laneSenderForAsync } from '../settled/send'
 import { type HerdrAsyncRunner, parseAgentList } from '../terminal/herdr'
 import { PLAN_LANGUAGE, type PlanLanguage } from '../vocabulary'
+import { REFERENCE } from '../watch/reference-paths'
 import { ASK_KIND, type AskTarget, boardRowKey } from './ask-target'
 import { errorText } from './error-text'
 import { isQuestionId } from './question-records'
@@ -18,29 +20,32 @@ export type AskDependencies = {
   /** The repository's directory name, from which the coordinator's herdr name follows. */
   repository: string
   run: HerdrAsyncRunner
+  /** Where the repository is looked up for the skill's reference; the working directory when omitted. */
+  cwd?: string
 }
 
 /** A sentence takes the subject's key and, for an entry of a source, the source it belongs to (else `''`). */
-type AskSentences = Record<AskTarget['kind'], (subject: string, scope: string) => string>
+type AskSentences = Record<AskTarget['kind'], (subject: string, scope: string, hint: string) => string>
 
 const ASK_LINES: Record<PlanLanguage, AskSentences> = {
   [PLAN_LANGUAGE.de]: {
-    [ASK_KIND.question]: (id) => `Stell mir die offene Frage ${id} jetzt (jh waiting).`,
-    [ASK_KIND.boardRow]: (key) => `Stell mir die offene Board-Zeile \`${key}\` jetzt (jh waiting).`,
+    [ASK_KIND.question]: (id, _scope, hint) => `Stell mir die offene Frage ${id} jetzt (jh waiting).${hint}`,
+    [ASK_KIND.boardRow]: (key, _scope, hint) =>
+      `Stell mir die offene Board-Zeile \`${key}\` jetzt (jh waiting).${hint}`,
     [ASK_KIND.appointmentRun]: (key) => `Führe den Termin \`${key}\` jetzt aus, unter den Freigaben, die er braucht.`,
     [ASK_KIND.appointmentMove]: (key) =>
       `Frag den User per Dialog nach der neuen Zeit für den Termin \`${key}\` und trag sie ins Board ein (verschobene Zeile = neuer Termin).`,
-    [ASK_KIND.sourceEntry]: (title, source) =>
-      `Sieh dir die Meldung \`${title}\` der Quelle \`${source}\` an und stell mir, falls nötig, die Frage dazu (jh waiting).`,
+    [ASK_KIND.sourceEntry]: (title, source, hint) =>
+      `Sieh dir die Meldung \`${title}\` der Quelle \`${source}\` an und stell mir, falls nötig, die Frage dazu (jh waiting).${hint}`,
   },
   [PLAN_LANGUAGE.en]: {
-    [ASK_KIND.question]: (id) => `Ask me the open question ${id} now (jh waiting).`,
-    [ASK_KIND.boardRow]: (key) => `Ask me the open board row \`${key}\` now (jh waiting).`,
+    [ASK_KIND.question]: (id, _scope, hint) => `Ask me the open question ${id} now (jh waiting).${hint}`,
+    [ASK_KIND.boardRow]: (key, _scope, hint) => `Ask me the open board row \`${key}\` now (jh waiting).${hint}`,
     [ASK_KIND.appointmentRun]: (key) => `Run the appointment \`${key}\` now, under the approvals it needs.`,
     [ASK_KIND.appointmentMove]: (key) =>
       `Ask the user in a dialog for the new time of the appointment \`${key}\` and write it into the board (a moved row is a new appointment).`,
-    [ASK_KIND.sourceEntry]: (title, source) =>
-      `Look at the report \`${title}\` of the source \`${source}\` and, if it needs it, put the question about it to me (jh waiting).`,
+    [ASK_KIND.sourceEntry]: (title, source, hint) =>
+      `Look at the report \`${title}\` of the source \`${source}\` and, if it needs it, put the question about it to me (jh waiting).${hint}`,
   },
 }
 
@@ -60,10 +65,11 @@ const scopeOf = (target: AskTarget): string =>
 /**
  * The line sent to the coordinator: a fixed sentence that carries the id of a question, or the sanitised key of a
  * row (`boardRowKey`), and nothing else from the board or the question, so a prompt line cannot be steered by
- * the file it reads. The caller checks the id with `isQuestionId`.
+ * the file it reads. The caller checks the id with `isQuestionId`. The sentences that send the coordinator to `jh waiting` end
+ * with `hint`, the reference that says how to put the question (none without the orchestrate skill).
  */
-export const askLine = (target: AskTarget, language: PlanLanguage): string =>
-  ASK_LINES[language][target.kind](subjectKeyOf(target), scopeOf(target))
+export const askLine = (target: AskTarget, language: PlanLanguage, hint = ''): string =>
+  ASK_LINES[language][target.kind](subjectKeyOf(target), scopeOf(target), hint)
 
 const isAskable = (target: AskTarget): boolean =>
   target.kind === ASK_KIND.question
@@ -114,7 +120,11 @@ export const askCoordinator = async (target: AskTarget, dependencies: AskDepende
   if ('reason' in coordinator) return TEXTS.notAsked(coordinator.reason)
   const failure = await laneSenderForAsync(dependencies.adapter, dependencies.run)(
     coordinator.name,
-    askLine(target, dependencies.language),
+    askLine(
+      target,
+      dependencies.language,
+      installedReferenceHintFor(dependencies.cwd ?? process.cwd(), REFERENCE.herdAsk),
+    ),
   )
   return failure === null ? TEXTS.asked(coordinator.name, subjectOf(target)) : TEXTS.notAsked(failure)
 }

package/src/plans/board-rows.ts

@@ -26,18 +26,23 @@ const newPartOf = (lane: SprintLane, step: PlanStep): PlanStep | null => {
   return rest.phaseIds.length > 0 ? rest : null
 }
 
-/** The lane with the checkout's steps it does not have yet; the same object when nothing is new. */
+/** Whether the lane is closed: the base says so, or the checkout marks it cleaned up before the mark is merged. */
+const closedBy = (known: SprintLane, checkout: SprintLane | undefined): boolean =>
+  known.closed || checkout?.closed === true
+
+/** The lane with the checkout's steps it does not have yet and its closed mark; the same object when nothing is new. */
 const grownBy = (known: SprintLane, checkout: SprintLane | undefined): SprintLane => {
-  const grown: SprintLane = { ...known, steps: [...known.steps] }
+  const grown: SprintLane = { ...known, steps: [...known.steps], closed: closedBy(known, checkout) }
   for (const step of checkout?.steps ?? []) {
     const part = newPartOf(grown, step)
     if (part !== null) grown.steps.push(part)
   }
-  return grown.steps.length > known.steps.length ? grown : known
+  return grown.steps.length > known.steps.length || grown.closed !== known.closed ? grown : known
 }
 
 /**
- * The board at the base ref with the rows only the checkout has. Base lanes keep their order and their rows;
+ * The board at the base ref with the rows only the checkout has. Base lanes keep their order and their rows, and are
+ * closed when the checkout marks them cleaned up, so the herd drops a lane before the mark reaches the base;
  * a lane only the checkout names is appended; a step of a known lane is added when the base does not name its
  * phases for that plan yet (identity: plan link and phase id), a row without a plan link when its label is new.
  * Both sides come parsed, this function reads no text.

package/src/plans/click-hint.ts

@@ -3,8 +3,10 @@ import { pullRequestNumberOfKey } from './pull-requests'
 import { LINKS_KEY_PREFIX } from './row-focus'
 import {
   BACKLOG_KEY,
+  entryBlockOfKey,
   finishedKey,
   isBlockFolded,
+  isEntryBlockFolded,
   isLaneOpen,
   isLanesOpen,
   isTaskRestKey,
@@ -55,6 +57,8 @@ const foldingHint = (key: string, state: Selection, agentOf: AgentOf): string |
   const lane = laneOfKey(key)
   if (lane !== null) return foldHint(isLaneOpen(state, lane, agentOf(lane)), lane)
   if (key === LANES_KEY) return foldHint(isLanesOpen(state), TEXTS.lanesHeading)
+  const entrySource = entryBlockOfKey(key)
+  if (entrySource !== null) return foldHint(!isEntryBlockFolded(state, entrySource), entrySource)
   const top = topBlockOfKey(key)
   if (top !== null) return foldHint(!isBlockFolded(state, top), TOP_BLOCK_NAMES[top])
   const open = state.expanded.has(key)

package/src/plans/command.ts

@@ -4,7 +4,7 @@ import { laneStatusSourceFor } from '../terminal'
 import { listHerdrAgents } from '../terminal/herdr'
 import { startedKit } from '../version/started-kit'
 import { boardFor, foundLanesOf } from './board-pick'
-import { ensurePlanPanes } from './ensure-panes'
+import { ensurePlanPaneRun } from './ensure-panes'
 import { mainCheckout, worktreeRoot } from './git'
 import { fetchPullRequests } from './github'
 import { claimOwnTerminal, startExclusive } from './herd-claim'
@@ -12,6 +12,7 @@ import { recallLanes, rememberLanes } from './herd-memory'
 import { publishedKey } from './herd-state'
 import { runLive } from './live'
 import { parseOptions } from './options'
+import { ENSURE_EXIT } from './plan-panes'
 import { isSupervisedChild } from './restart-decision'
 import { type PlansSettings, readSettings } from './settings'
 import { loadSnapshot, type Source } from './snapshot'
@@ -55,12 +56,12 @@ export const run = async (args: string[], home: string = homedir()): Promise<num
       foundLanesOf(root, settings, () => terminal.listAgents().map((agent) => agent.name)),
     )
     if (options.ensure) {
-      const lines =
+      const { lines, exitCode } =
         settings.adapter === TERMINAL_ADAPTER.herdr
-          ? ensurePlanPanes(root, settings, picked.file)
-          : ['the terminal adapter is not herdr: no panes to bring back']
+          ? ensurePlanPaneRun(root, settings, picked.file)
+          : { lines: ['the terminal adapter is not herdr: no panes to bring back'], exitCode: ENSURE_EXIT.done }
       for (const line of lines.length > 0 ? lines : ['every herd pane is running']) console.log(line)
-      return 0
+      return exitCode
     }
     const source: Source = { root, sprintFile: picked.file, options, settings, terminal, ...agentListOf(settings) }
     if (options.once || !process.stdout.isTTY) await printOnceWithNotice(source, picked.notice)

package/src/plans/ensure-panes.ts

@@ -8,6 +8,8 @@ import {
   agentPanesOf,
   coordinatorLabelOf,
   coordinatorPaneOf,
+  type EnsureExit,
+  ensureExitOf,
   foregroundOf,
   missingCoordinatorNote,
   type PaneAction,
@@ -60,9 +62,14 @@ const labelCoordinator = (label: { pane: string; label: string } | null) => {
 /**
  * `herd --ensure`: brings back every missing herd pane 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. The coordinator's pane is labelled `🐾 Jack` on the way.
+ * action or skipped target, none when every view runs, and the exit code (`ENSURE_EXIT`) that says whether the
+ * coordinator's pane was found. The coordinator's pane is labelled `🐾 Jack` on the way.
  */
-export const ensurePlanPanes = (root: string, settings: PlansSettings, boardFile: string): string[] => {
+export const ensurePlanPaneRun = (
+  root: string,
+  settings: PlansSettings,
+  boardFile: string,
+): { lines: string[]; exitCode: EnsureExit } => {
   const agents = runHerdr(['agent', 'list'])
   const listed = parseAgentList(agents)
   const panes = panesWithForeground(agentPanesOf(agents))
@@ -84,5 +91,9 @@ export const ensurePlanPanes = (root: string, settings: PlansSettings, boardFile
     command: (lane) => viewCommandOf(process.argv, lane),
     missingCoordinator: missingCoordinatorNote(panes, root, coordinatorName),
   })
-  return [...actions.map(apply), ...notes]
+  return { lines: [...actions.map(apply), ...notes], exitCode: ensureExitOf(panes, coordinator) }
 }
+
+/** The lines of `ensurePlanPaneRun`, for a caller that brings the panes back without an exit code (the watcher). */
+export const ensurePlanPanes = (root: string, settings: PlansSettings, boardFile: string): string[] =>
+  ensurePlanPaneRun(root, settings, boardFile).lines

package/src/plans/git.ts

@@ -39,6 +39,11 @@ export const showAtRef = (root: string, ref: string, path: string): string | nul
   return result.exitCode === 0 ? result.stdout.toString() : null
 }
 
+/** Whether `path` (from the repository root, without `..`) exists at `ref`. */
+export const existsOnRef = (root: string, ref: string, path: string): boolean =>
+  Bun.spawnSync(['git', '-C', root, 'cat-file', '-e', `${ref}:${path}`], { stdout: 'ignore', stderr: 'ignore' })
+    .exitCode === 0
+
 /** 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}`])
@@ -151,6 +156,15 @@ export const mainCheckout = (cwd: string): string => {
   return dirname(commonDirectory)
 }
 
+/** `mainCheckout`, null outside a git checkout instead of git's error. */
+export const mainCheckoutOrNull = (cwd: string): string | null => {
+  try {
+    return mainCheckout(cwd)
+  } catch {
+    return null
+  }
+}
+
 /** 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'])

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)] : []),