jackherd 1.8.1 → 1.10.0

package/src/plans/subagent-phases.ts

@@ -0,0 +1,95 @@
+import { isPhaseOpen, type PlanPhase } from '../plan-format'
+import { PHASE_ID_PREFIX, spannedPhaseIds } from '../plan-format/lanes'
+import { isNamedBy } from './phase-ids'
+
+/** The agent types that review a phase; they sit on its review gate. */
+export const REVIEW_TYPE = {
+  uncleBob: 'uncle-bob',
+  specReview: 'spec-review',
+  securityAudit: 'security-audit',
+  review: 'review',
+  ive: 'ive',
+  jobs: 'jobs',
+} as const
+
+export type ReviewType = (typeof REVIEW_TYPE)[keyof typeof REVIEW_TYPE]
+
+/**
+ * The phases a running subagent names in its description, its review type (null for no review), and when its log was
+ * last written. `ids` is empty only for a review that names no phase: the lane places it (`PhaselessReview`).
+ */
+export type SubagentPhaseRun = { ids: string[]; review: ReviewType | null; at: number }
+
+/** A running review whose description names no phase: it sits on the lane's signalled phase, else shows as its description. */
+export type PhaselessReview = { review: ReviewType; at: number; description: string | null }
+
+/** What the subagents say about one phase of the lane: the types of the reviews among them, and the newest log write. */
+export type SubagentPhase = { reviews: ReviewType[]; at: number }
+
+const isReviewTypeName = (type: string): type is ReviewType => (Object.values(REVIEW_TYPE) as string[]).includes(type)
+
+/** `P21`, `P17-P20`, `P17 – 19`, `Phase 21`, `Phase 10c`: the first number, an optional sub-phase letter, an optional end. */
+const PHASE_MENTION = new RegExp(
+  `(?:\\b${PHASE_ID_PREFIX}|\\bPhase\\s+)(\\d+)([a-z]?)(?:\\s*[-–—]\\s*(?:${PHASE_ID_PREFIX})?(\\d+)\\b)?`,
+  'gi',
+)
+
+/** The ids of a range `first`-`last`; a range that runs backwards or is absurdly wide names only its first end. */
+const rangeIds = (first: number, last: number): string[] => {
+  const spanned = spannedPhaseIds(first, last)
+  return spanned.length > 0 ? spanned : [String(first)]
+}
+
+/** The ids of the phases a description names, in the order named; a range names every phase between its ends. */
+export const phaseIdsOfDescription = (description: string): string[] =>
+  [...description.matchAll(PHASE_MENTION)].flatMap(([, first = '', letter = '', last]) =>
+    last === undefined ? [`${Number(first)}${letter.toLowerCase()}`] : rangeIds(Number(first), Number(last)),
+  )
+
+const withoutPrefix = (type: string, prefixes: readonly string[]): string => {
+  const prefix = prefixes.find((each) => each !== '' && type.startsWith(each))
+  return prefix === undefined ? type : type.slice(prefix.length)
+}
+
+/** The `REVIEW_TYPE` an agent type is, plain or with one of the skill `prefixes` of a copy; null for any other type. */
+export const reviewTypeOf = (type: string | null, prefixes: readonly string[]): ReviewType | null => {
+  const plain = type === null ? null : withoutPrefix(type, prefixes)
+  return plain !== null && isReviewTypeName(plain) ? plain : null
+}
+
+/**
+ * The run of a subagent from its `description` and `agentType`: null when the description names no phase and the
+ * subagent is no review. The description is read whole, not cut for the display.
+ */
+export const subagentPhaseRunOf = (
+  description: string | null,
+  agentType: string | null,
+  at: number,
+  reviewPrefixes: readonly string[],
+): SubagentPhaseRun | null => {
+  const ids = description === null ? [] : phaseIdsOfDescription(description)
+  const review = reviewTypeOf(agentType, reviewPrefixes)
+  return ids.length === 0 && review === null ? null : { ids, review, at }
+}
+
+const names = (run: SubagentPhaseRun, id: string): boolean => isNamedBy(id, new Set(run.ids))
+
+const reviewsOf = (runs: readonly SubagentPhaseRun[]): ReviewType[] => [
+  ...new Set(runs.flatMap(({ review }) => (review === null ? [] : [review]))),
+]
+
+/**
+ * The open phases of the lane that running subagents name, by phase id: a sub-phase (`21b`) is named by its main phase.
+ * Phases the lane does not hold are left out, since another lane's phases are not its own.
+ */
+export const subagentPhases = (
+  phases: readonly Pick<PlanPhase, 'id' | 'items'>[],
+  runs: readonly SubagentPhaseRun[],
+): Map<string, SubagentPhase> =>
+  new Map(
+    phases.filter(isPhaseOpen).flatMap(({ id }) => {
+      const naming = runs.filter((run) => names(run, id))
+      if (naming.length === 0) return []
+      return [[id, { reviews: reviewsOf(naming), at: Math.max(...naming.map(({ at }) => at)) }]]
+    }),
+  )

package/src/plans/subagent-tasks.ts

@@ -0,0 +1,51 @@
+import type { ActiveTask } from './active-tasks'
+import type { TaskPhase } from './current-task'
+import { taskNameOf } from './task-name'
+
+/** A running subagent that is no review: its description as the herd shows it, and when its log was last written. */
+export type DescribedSubagent = { description: string; at: number }
+
+/** Where the subagents sit: their tasks by phase id, and the descriptions placed, which show no line of their own. */
+export type SubagentTaskPlacements = { byPhase: Map<string, ActiveTask[]>; placed: string[] }
+
+type NamedTask = { phaseId: string; index: number; name: string }
+
+/** A letter or digit right after the name continues a word, so `Probe` does not name `Proben lesen`. */
+const WORD_GOES_ON = /^[\p{L}\p{N}]/u
+
+/** The open tasks that carry a short name, the longest names first, so a name that starts another loses to it. */
+const namedOpenTasks = (phases: readonly TaskPhase[]): NamedTask[] =>
+  phases
+    .flatMap(({ id, items }) =>
+      items.flatMap((item, index) => {
+        const name = item.done || item.gate ? null : taskNameOf(item.text)
+        return name === null ? [] : [{ phaseId: id, index, name }]
+      }),
+    )
+    .sort((first, second) => second.name.length - first.name.length)
+
+const startsWithName = (description: string, name: string): boolean =>
+  description.toLowerCase().startsWith(name.toLowerCase()) && !WORD_GOES_ON.test(description.slice(name.length))
+
+/**
+ * The open task each subagent works on, from the short name its description starts with (`/implement` Step 0b, case
+ * ignored): it gets its `▶` like a reported task, one per task however many subagents share it. A ticked task and a
+ * review gate item take none; a subagent whose description starts with no name stays where it was.
+ */
+export const subagentTaskPlacements = (
+  phases: readonly TaskPhase[],
+  subagents: readonly DescribedSubagent[],
+): SubagentTaskPlacements => {
+  const tasks = namedOpenTasks(phases)
+  const byPhase = new Map<string, ActiveTask[]>()
+  const placed: string[] = []
+  for (const { description, at } of subagents) {
+    const task = tasks.find(({ name }) => startsWithName(description, name))
+    if (task === undefined) continue
+    placed.push(description)
+    const known = byPhase.get(task.phaseId) ?? []
+    if (known.some(({ index }) => index === task.index)) continue
+    byPhase.set(task.phaseId, [...known, { index: task.index, agent: null, guessed: false, startedAt: at }])
+  }
+  return { byPhase, placed }
+}

package/src/plans/subagents-read.ts

@@ -0,0 +1,131 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import { defaultProjectsDirectory, projectDirectoryOf, readTailLines } from '../context/session-log'
+import { MS_PER_MINUTE } from '../plan-format/clock'
+import { DEFAULT_SKILL_PREFIX } from '../sync/init'
+import { readApprovalRequests } from '../watch/approvals'
+import {
+  type RunningSubagent,
+  runningSubagents,
+  SUBAGENT_STALE_MINUTES,
+  type SubagentActivity,
+  type SubagentLog,
+  subagentsByLane,
+} from './subagents'
+
+export type SubagentSource = {
+  projects: string
+  /** The main checkout whose sessions are read. */
+  root: string
+  /** The main checkout whose `.jackherd/approvals/` holds the gate's requests. */
+  approvalsRoot: string
+  /** The absolute worktree directory. */
+  worktreeDirectory: string
+  /** The project's `skillPrefix`, which its copies of the review agents carry; without it only the default one counts. */
+  skillPrefix?: string
+}
+
+/** The source of the main checkout `root`: Claude Code's own session logs, the gate's requests in the checkout itself. */
+export const subagentSourceOf = (root: string, worktreeDirectory: string, skillPrefix?: string): SubagentSource => ({
+  projects: defaultProjectsDirectory(),
+  root,
+  approvalsRoot: root,
+  worktreeDirectory,
+  skillPrefix,
+})
+
+/** The end of a log that holds the directory of the last entries. */
+const TAIL_BYTES = 64 * 1024
+const META_FILE = /^agent-([0-9a-f]+)\.meta\.json$/
+/** A request the gate holds is reported for this long, as by the watcher. */
+const OPEN_REQUEST_MINUTES = 30
+
+const directoriesOf = (path: string): string[] => {
+  try {
+    return readdirSync(path, { withFileTypes: true }).flatMap((entry) => (entry.isDirectory() ? [entry.name] : []))
+  } catch {
+    return []
+  }
+}
+
+/** The entry names of `path`; none when it is missing or cannot be read. */
+const namesIn = (path: string): string[] => {
+  try {
+    return readdirSync(path)
+  } catch {
+    return []
+  }
+}
+
+const logOf = (directory: string, name: string, id: string, now: number): SubagentLog[] => {
+  try {
+    const logPath = join(directory, `agent-${id}.jsonl`)
+    const modifiedAt = statSync(logPath).mtimeMs
+    if (now - modifiedAt > SUBAGENT_STALE_MINUTES * MS_PER_MINUTE) return []
+    const meta: unknown = JSON.parse(readFileSync(join(directory, name), 'utf8'))
+    return [{ id, meta, modifiedAt, tail: readTailLines(logPath, TAIL_BYTES) }]
+  } catch {
+    return []
+  }
+}
+
+/** The subagent logs of every session in one project directory. */
+const sessionLogsOf = (project: string, now: number): SubagentLog[] =>
+  directoriesOf(project).flatMap((session) => {
+    const directory = join(project, session, 'subagents')
+    return namesIn(directory).flatMap((name) => {
+      const id = META_FILE.exec(name)?.[1]
+      return id ? logOf(directory, name, id, now) : []
+    })
+  })
+
+/**
+ * The project directories Claude Code keeps for sessions started in the main checkout `root` and, when
+ * `worktreeDirectory` is given, in a worktree below it: a lane's own subagents, its reviews among them, live there.
+ */
+const projectDirectoriesOf = (projects: string, root: string, worktreeDirectory?: string): string[] => {
+  const main = projectDirectoryOf(root)
+  const lanes = worktreeDirectory === undefined ? null : `${projectDirectoryOf(worktreeDirectory)}-`
+  return directoriesOf(projects).filter((name) => name === main || (lanes !== null && name.startsWith(lanes)))
+}
+
+/**
+ * The subagents with a recently written log in the sessions started in the main checkout `root` and its worktrees,
+ * from Claude Code's `<projects>/<project>/<session>/subagents/agent-<id>.{meta.json,jsonl}`; whatever cannot be read
+ * is left out.
+ */
+export const readSubagentLogs = (
+  projects: string,
+  root: string,
+  now: number,
+  worktreeDirectory?: string,
+): SubagentLog[] =>
+  projectDirectoriesOf(projects, root, worktreeDirectory).flatMap((name) => sessionLogsOf(join(projects, name), now))
+
+/** The names the gate holds an open request under, as the watcher reads them. */
+const heldNames = (root: string, now: number): Set<string> =>
+  new Set(
+    readApprovalRequests(root)
+      .filter((request) => request.usedAt === null && now - request.createdAt <= OPEN_REQUEST_MINUTES * MS_PER_MINUTE)
+      .map((request) => request.lane),
+  )
+
+/**
+ * The subagents at work in the sessions of the main checkout and its worktrees: their logs read, the finished and the
+ * stale left out. The one chain the herd (`readSubagentActivity`) and the watcher's heartbeat share.
+ */
+export const readRunningSubagents = (
+  { projects, root, approvalsRoot, worktreeDirectory, skillPrefix }: SubagentSource,
+  now: number = Date.now(),
+): RunningSubagent[] =>
+  runningSubagents(
+    readSubagentLogs(projects, root, now, worktreeDirectory),
+    heldNames(approvalsRoot, now),
+    now,
+    worktreeDirectory,
+    skillPrefix === undefined ? [DEFAULT_SKILL_PREFIX] : [DEFAULT_SKILL_PREFIX, skillPrefix],
+  )
+
+/** The state of every worktree a subagent of the main checkout's sessions works in. */
+export const readSubagentActivity = (source: SubagentSource, now: number = Date.now()): Map<string, SubagentActivity> =>
+  subagentsByLane(readRunningSubagents(source, now), source.worktreeDirectory)

package/src/plans/subagents.ts

@@ -0,0 +1,190 @@
+import { parseLogEntry } from '../context/session-log'
+import { MS_PER_MINUTE } from '../plan-format/clock'
+import { terminalSafe } from '../plan-format/terminal-text'
+import { isRecord } from '../shared/is-record'
+import { AGENT_STATUS, type AgentStatus } from '../terminal/types'
+import { activityTextOf } from './current-task'
+import { type PhaselessReview, type SubagentPhaseRun, subagentPhaseRunOf } from './subagent-phases'
+import type { DescribedSubagent } from './subagent-tasks'
+import { laneDirectoryOf } from './unlisted-lanes'
+
+/** What the log files of one subagent say: its id, its `meta.json` as parsed, when the log was written, its last lines. */
+export type SubagentLog = { id: string; meta: unknown; modifiedAt: number; tail: readonly string[] }
+
+/** A subagent of the coordinator that is at work now. */
+export type RunningSubagent = {
+  label: string
+  cwd: string | null
+  description: string | null
+  status: Extract<AgentStatus, 'working' | 'blocked'>
+  /** The text of its last log entries, from which the herd tells the task it works on (`taskSignalsOf`). */
+  activity: string
+  /** The phases its full description names (`P21`, `P17-P20`), none for a review that names none; null for any other. */
+  phaseRun: SubagentPhaseRun | null
+  /** When its log was last written. */
+  writtenAt: number
+}
+
+/** What a worktree shows of the subagents working in it; `phaseRuns` are those of all its subagents that name a phase. */
+export type SubagentActivity = Pick<RunningSubagent, 'status' | 'description' | 'activity'> & {
+  phaseRuns: SubagentPhaseRun[]
+  /** Its reviews that name no phase; the lane places them on its signalled phase (`laneSummary`). */
+  phaselessReviews: PhaselessReview[]
+  /**
+   * The descriptions of its other subagents that name no phase: what they work on, a signal of the lane like a
+   * reported task.
+   */
+  taskDescriptions: string[]
+  /** Its subagents that are no review, phase or not; one whose description starts with a task's short name sits on it. */
+  describedSubagents: DescribedSubagent[]
+}
+
+/**
+ * A log untouched this long is not at work: Claude Code marks a finished subagent with `finished: true` in its
+ * `meta.json` only in its newer versions, so a subagent that was killed or ended before that has no mark.
+ */
+export const SUBAGENT_STALE_MINUTES = 15
+const AGENT_ID = /^[0-9a-f]{8,64}$/
+const AGENT_TYPE = /^[a-z0-9][a-z0-9-]{0,31}$/
+const ID_LENGTH = 8
+const ACTIVITY_ENTRIES = 40
+const DESCRIPTION_LENGTH = 80
+
+/** The name the approval gate holds a subagent under (`kit/hooks/hooks/approval-gate/subagent.ts`, contract test). */
+export const subagentLabelOf = (id: string, type: string | null): string | null =>
+  AGENT_ID.test(id)
+    ? `subagent-${type !== null && AGENT_TYPE.test(type) ? type : 'agent'}-${id.slice(0, ID_LENGTH)}`
+    : null
+
+const textOrNull = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null)
+
+const escapeRegExp = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+/** The strings a tool call of a log entry carries as paths: `file_path`, `path` and the `command` of a shell call. */
+const toolCallTexts = (entry: Record<string, unknown>): string[] => {
+  const content = isRecord(entry.message) && Array.isArray(entry.message.content) ? entry.message.content : []
+  return content.flatMap((block) => {
+    if (!isRecord(block) || block.type !== 'tool_use' || !isRecord(block.input)) return []
+    return [block.input.file_path, block.input.path, block.input.command].filter(
+      (value): value is string => typeof value === 'string',
+    )
+  })
+}
+
+/** The last worktree below `worktreeDirectory` that a text names, as its directory; null when it names none. */
+const lastWorktreeIn = (text: string, worktreeDirectory: string): string | null => {
+  const pattern = new RegExp(`${escapeRegExp(worktreeDirectory)}/([A-Za-z0-9._-]+)`, 'g')
+  const name = [...text.matchAll(pattern)].at(-1)?.[1]
+  return name === undefined ? null : `${worktreeDirectory}/${name}`
+}
+
+/**
+ * Where the subagent works: the worktree its most recent tool call names (a path, or a path in a shell command), since
+ * a coordinator's subagent starts in the main directory and changes directory per command, so its entries carry that
+ * directory; else the directory of the last entry that names one. Lines that are no JSON (the cut-off first one) are
+ * skipped.
+ */
+const workingDirectory = (tail: readonly string[], worktreeDirectory: string): string | null => {
+  const entries = [...tail].reverse().flatMap((line): Record<string, unknown>[] => {
+    const entry = parseLogEntry(line)
+    return entry === null ? [] : [entry]
+  })
+  for (const entry of entries) {
+    for (const text of toolCallTexts(entry).reverse()) {
+      const named = lastWorktreeIn(text, worktreeDirectory)
+      if (named !== null) return named
+    }
+  }
+  const directory = entries.find((entry) => typeof entry.cwd === 'string')?.cwd
+  return typeof directory === 'string' ? directory : null
+}
+
+/**
+ * The subagents at work: no `finished` mark in the meta, and the log written within `SUBAGENT_STALE_MINUTES`. One
+ * waits for an answer while the approval gate holds a request under its name (`openRequests` are the names of the open
+ * requests); the transcript alone cannot tell a permission dialog from a long tool call. `reviewPrefixes` are the skill
+ * prefixes a copy of the review agents may carry.
+ */
+export const runningSubagents = (
+  logs: readonly SubagentLog[],
+  openRequests: ReadonlySet<string>,
+  now: number,
+  worktreeDirectory: string,
+  reviewPrefixes: readonly string[],
+): RunningSubagent[] =>
+  logs.flatMap(({ id, meta, modifiedAt, tail }) => {
+    if (!isRecord(meta) || meta.finished === true || now - modifiedAt > SUBAGENT_STALE_MINUTES * MS_PER_MINUTE)
+      return []
+    const agentType = textOrNull(meta.agentType)
+    const label = subagentLabelOf(id, agentType)
+    if (label === null) return []
+    const description = textOrNull(typeof meta.description === 'string' ? terminalSafe(meta.description) : null)
+    const shortDescription = description?.slice(0, DESCRIPTION_LENGTH) ?? null
+    return [
+      {
+        label,
+        cwd: workingDirectory(tail, worktreeDirectory),
+        description: shortDescription,
+        status: openRequests.has(label) ? AGENT_STATUS.blocked : AGENT_STATUS.working,
+        activity: activityTextOf(tail, ACTIVITY_ENTRIES),
+        phaseRun: subagentPhaseRunOf(description, agentType, modifiedAt, reviewPrefixes),
+        writtenAt: modifiedAt,
+      },
+    ]
+  })
+
+/** The description of a subagent that names no phase, as a list of at most one; empty for a review or one that names a phase. */
+const taskDescriptionOf = ({ phaseRun, description }: RunningSubagent): string[] =>
+  phaseRun === null && description !== null ? [description] : []
+
+/** A subagent that is no review, with its description, as a list of at most one. */
+const describedSubagentOf = ({ phaseRun, description, writtenAt }: RunningSubagent): DescribedSubagent[] =>
+  description !== null && (phaseRun === null || phaseRun.review === null) ? [{ description, at: writtenAt }] : []
+
+/** The run of a subagent that names a phase, as a list of at most one. */
+const namedRunOf = ({ phaseRun }: RunningSubagent): SubagentPhaseRun[] =>
+  phaseRun !== null && phaseRun.ids.length > 0 ? [phaseRun] : []
+
+/** A review that names no phase, as a list of at most one. */
+const phaselessReviewOf = ({ phaseRun, description }: RunningSubagent): PhaselessReview[] => {
+  if (phaseRun === null || phaseRun.review === null || phaseRun.ids.length > 0) return []
+  return [{ review: phaseRun.review, at: phaseRun.at, description }]
+}
+
+/** The worktrees below `worktreeDirectory` the subagents work in; one that waits for an answer decides the state. */
+export const subagentsByLane = (
+  running: readonly RunningSubagent[],
+  worktreeDirectory: string,
+): Map<string, SubagentActivity> => {
+  const lanes = new Map<string, SubagentActivity>()
+  for (const subagent of running) {
+    const { cwd, status, description, activity } = subagent
+    const lane = cwd === null ? null : laneDirectoryOf(cwd, worktreeDirectory)
+    if (lane === null) continue
+    const known = lanes.get(lane)
+    const runs = namedRunOf(subagent)
+    const reviews = phaselessReviewOf(subagent)
+    const tasks = taskDescriptionOf(subagent)
+    const described = describedSubagentOf(subagent)
+    if (!known)
+      lanes.set(lane, {
+        status,
+        description,
+        activity,
+        phaseRuns: runs,
+        phaselessReviews: reviews,
+        taskDescriptions: tasks,
+        describedSubagents: described,
+      })
+    else
+      lanes.set(lane, {
+        ...(status === AGENT_STATUS.blocked && known.status !== AGENT_STATUS.blocked ? { status, description } : known),
+        activity: `${known.activity} ${activity}`,
+        phaseRuns: [...known.phaseRuns, ...runs],
+        phaselessReviews: [...known.phaselessReviews, ...reviews],
+        taskDescriptions: [...known.taskDescriptions, ...tasks],
+        describedSubagents: [...known.describedSubagents, ...described],
+      })
+  }
+  return lanes
+}

package/src/plans/supervisor.ts

@@ -4,6 +4,7 @@ import { dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { pendingKitUpdate, VERSION_POLL_MS } from '../version/installed-version'
 import type { StartedKit } from '../version/started-kit'
+import { STOP_REQUEST, type Stopper, stopperOf } from './child-stop'
 import { HERD_COMMAND } from './herd-command'
 import { CHILD_MARKER, exitCodeOf, isRestartTrigger, nextStep, RESTART_DEBOUNCE_MS } from './restart-decision'
 import { TERMINAL_OFF } from './view'
@@ -30,7 +31,8 @@ const spawnView = (scriptPath: string, args: string[]): ChildProcess =>
 /**
  * Runs the live view as a child process and restarts it when the package's own source changes,
  * so a long-lived `plans` never shows the behaviour of code that has since been edited. The child
- * stops on SIGTERM through the handler that restores the terminal. Resolves with the exit code
+ * stops on SIGTERM through the handler that restores the terminal, and is killed when it does not end within
+ * `GRACE_MS` (a restart included); a second signal while stopping kills it at once. Resolves with the exit code
  * of a wanted end only: the child's clean exit (`q`) or a signal forwarded to it. A child that
  * dies otherwise leaves the supervisor waiting, with the terminal restored, for the next change
  * to `src/`, which spawns a fresh child. `kit` is the package this process loaded (null when it cannot be
@@ -45,6 +47,7 @@ export const superviseView = (
 ): Promise<number> =>
   new Promise((resolveExit) => {
     let child: ChildProcess | undefined
+    let stopper: Stopper | undefined
     let restarting = false
     let stopping = false
     let timer: ReturnType<typeof setTimeout> | undefined
@@ -66,6 +69,12 @@ export const superviseView = (
     const start = (isFirst: boolean): void => {
       const current = spawnView(scriptPath, args)
       child = current
+      const currentStopper = stopperOf({
+        kill: (signal) => current.kill(signal),
+        setTimer: (run, ms) => setTimeout(run, ms),
+        clearTimer: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
+      })
+      stopper = currentStopper
 
       current.on('error', (error) => {
         if (child !== current) return
@@ -79,6 +88,7 @@ export const superviseView = (
       })
 
       current.on('exit', (code, signal) => {
+        currentStopper.ended()
         if (child !== current) return
         const context = { restarting, stopping, code, signal }
         restarting = false
@@ -94,7 +104,7 @@ export const superviseView = (
     const restartView = (): void => {
       if (child) {
         restarting = true
-        child.kill('SIGTERM')
+        stopper?.request('SIGTERM')
       } else start(false)
     }
 
@@ -118,8 +128,8 @@ export const superviseView = (
         stopping = true
         clearTimeout(timer)
         clearInterval(versionTimer)
-        if (child) child.kill(signal)
-        else finish(exitCodeOf(null, signal))
+        if (!child || !stopper) finish(exitCodeOf(null, signal))
+        else if (stopper.request(signal) === STOP_REQUEST.killed) finish(exitCodeOf(null, signal))
       })
     }
   })

package/src/plans/symbols.ts

@@ -21,6 +21,9 @@ export const statusWord = (agent: string | null): string => agent ?? NO_AGENT_WO
 /** Before a row that opens and closes: lanes, the planned phases, the ticked items of a phase. */
 export const CHEVRON = { closed: '▸', open: '▾' } as const
 
+/** Before the count under a block that shows all its rows; a click folds it back to five. */
+export const LESS_MARK = '▴'
+
 export const chevronOf = (open: boolean): string => (open ? CHEVRON.open : CHEVRON.closed)
 
 export const PHASE_STATE = { missing: 'missing', empty: 'empty', all: 'all', open: 'open' } as const

package/src/plans/task-name.ts

@@ -0,0 +1,34 @@
+const TASK_NAME = /^\*\*([^*]+)\*\*:/
+
+const TITLE_END = ': '
+
+const titleEndOf = (text: string): number => {
+  let inCode = false
+  for (let index = 0; index < text.length; index++) {
+    if (text[index] === '`') inCode = !inCode
+    else if (!inCode && text.startsWith(TITLE_END, index)) return index
+  }
+  return -1
+}
+
+/**
+ * The text up to its first colon followed by a space outside backticks, as a folded row shows it; the text as it is
+ * without such a colon or with nothing before it. A time like `18:55` has no space after its colon and does not split.
+ */
+export const shortTitle = (text: string): string => {
+  const end = titleEndOf(text)
+  return end > 0 ? text.slice(0, end) : text
+}
+
+/**
+ * The short name a task carries in bold at its start, `**Name**: content`, as written; null for a line without one.
+ * Nothing is guessed from the text up to its first colon: a path at the start of a line would read as a name.
+ */
+export const taskNameOf = (text: string): string | null => {
+  const name = text.match(TASK_NAME)?.[1]?.trim()
+  return name ? name : null
+}
+
+/** The text after a task's `**Name**:`, as an opened task shows it under its name; the text as it is without a name. */
+export const taskBodyOf = (text: string): string =>
+  taskNameOf(text) === null ? text : text.replace(TASK_NAME, '').trimStart()