jackherd 1.4.0 → 1.6.0

package/src/sync/project-fs.ts

@@ -1,6 +1,6 @@
 import { randomBytes } from 'node:crypto'
-import { lstat, mkdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises'
-import { basename, dirname, join, sep } from 'node:path'
+import { lstat, mkdir, readdir, readFile, realpath, rename, rm, rmdir, writeFile } from 'node:fs/promises'
+import { basename, dirname, join, normalize, sep } from 'node:path'
 import { CLAUDE_DIRECTORY } from '../claude/paths'
 import { TOOL_DIRECTORY } from '../config/location'
 import { checksum } from './checksum'
@@ -86,6 +86,32 @@ export const removeFileSafely = async (directory: string, path: string): Promise
   if (state.kind === 'file') await rm(join(directory, path))
 }
 
+export const DIRECTORY_OUTCOME = { removed: 'removed', notEmpty: 'notEmpty', skipped: 'skipped' } as const
+
+export type DirectoryOutcome = (typeof DIRECTORY_OUTCOME)[keyof typeof DIRECTORY_OUTCOME]
+
+/**
+ * Removes a real, empty directory and nothing else: a link, a file or a directory with any entry (a dotfile
+ * included) stays, and so does the directory itself that `path` names as `.`, and `rmdir` itself refuses what turned out not to be empty between the check and the call.
+ */
+export const removeEmptyDirectory = async (directory: string, path: string): Promise<DirectoryOutcome> => {
+  if (normalize(path) === '.') return DIRECTORY_OUTCOME.skipped
+  // `hasPlainAncestors` looks at the directories above a file path, so a child segment stands in for one.
+  if (!(await hasPlainAncestors(directory, `${path}/entry`))) return DIRECTORY_OUTCOME.skipped
+  const target = join(directory, path)
+  const entry = await lstatOrMissing(target)
+  if (!entry?.isDirectory()) return DIRECTORY_OUTCOME.skipped
+  if ((await readdir(target)).length > 0) return DIRECTORY_OUTCOME.notEmpty
+  try {
+    await rmdir(target)
+    return DIRECTORY_OUTCOME.removed
+  } catch (err) {
+    if (typeof err === 'object' && err !== null && 'code' in err && (err.code === 'ENOTEMPTY' || err.code === 'EEXIST'))
+      return DIRECTORY_OUTCOME.notEmpty
+    throw err
+  }
+}
+
 /** Creates the file only if nothing is at the path yet; returns false and writes nothing otherwise. */
 export const createFileExclusively = async (directory: string, path: string, content: string): Promise<boolean> => {
   if ((await readLocalState(directory, path)).kind !== 'missing') return false

package/src/sync/render.ts

@@ -1,5 +1,6 @@
 import type { JackherdConfig } from '../config'
-import { LANGUAGE_NAME, PLAN_VOCABULARY, SELF_MERGE_LABEL } from '../vocabulary'
+import { frozenInstallCommand } from '../config/detect'
+import { ADDRESS_FORM, LANGUAGE_NAME, PLAN_VOCABULARY, SELF_MERGE_LABEL } from '../vocabulary'
 
 const PLACEHOLDER = /\{\{\s*(kit\.[A-Za-z0-9_.-]*)\s*\}\}/g
 
@@ -12,14 +13,19 @@ const laneCopyCommand = (copy: readonly string[]): string =>
     ? WORKTREE_INCLUDE_COPY
     : `cd <main-checkout> && cp -p --parents -- ${copy.map((path) => `'${path}'`).join(' ')} <worktree>/`
 
+/** The patterns a pull request may match to be merged without checks, as prose for a skill; `none` for an empty list. */
+const checkFreeList = (patterns: readonly string[]): string =>
+  patterns.length === 0 ? 'none' : patterns.map((pattern) => `\`${pattern}\``).join(', ')
+
 const prefixed = (prefix: string, values: Record<string, string>): [string, string][] =>
   Object.entries(values).map(([key, value]) => [`kit.${prefix}.${key}`, value])
 
 /** Every placeholder a kit file may use, with its value for this project. */
 const placeholderValues = (config: JackherdConfig): Map<string, string> => {
-  const { header, sections, columns, phase } = PLAN_VOCABULARY[config.planLanguage]
+  const { header, sections, columns, phase, laneClosed } = PLAN_VOCABULARY[config.planLanguage]
   return new Map([
     ['kit.responseLanguage', LANGUAGE_NAME[config.responseLanguage]],
+    ['kit.responseAddress', ADDRESS_FORM[config.responseLanguage][config.responseAddress]],
     ['kit.planLanguage', LANGUAGE_NAME[config.planLanguage]],
     ['kit.planDirectory', config.planDirectory],
     ['kit.baseBranch', config.baseBranch],
@@ -28,9 +34,12 @@ const placeholderValues = (config: JackherdConfig): Map<string, string> => {
     ...prefixed('command', config.commands),
     ['kit.lanes.copyCommand', laneCopyCommand(config.lanes.copy)],
     ['kit.lanes.lockFile', config.lanes.lockFile],
+    ['kit.lanes.verifyInstall', frozenInstallCommand(config.commands.install)],
+    ['kit.word.laneClosed', laneClosed],
     ...prefixed('board', config.board),
     ['kit.guard.selfMergeLabel', SELF_MERGE_LABEL[config.responseLanguage]],
     ['kit.guard.selfMerge', config.guard.selfMerge.offer ? 'offered' : 'not offered'],
+    ['kit.merge.withoutChecks', checkFreeList(config.merge.withoutChecks)],
     ...prefixed('heading', { ...header, ...sections, ...columns, phase }),
   ])
 }
@@ -41,9 +50,9 @@ export const listPlaceholders = (template: string): string[] =>
 
 /**
  * Fills the kit placeholders from the project config: `{{kit.model.<role>}}`,
- * `{{kit.command.<test|typecheck|lint|format|install|dev>}}`, `{{kit.lanes.<copyCommand|lockFile>}}`,
- * `{{kit.board.<pattern|file|term>}}`, `{{kit.guard.<selfMerge|selfMergeLabel>}}`, `{{kit.heading.<key>}}` from the plan
- * vocabulary, the two languages, the plan and worktree directory and the base branch. Other
+ * `{{kit.command.<test|typecheck|lint|format|install|dev>}}`, `{{kit.lanes.<copyCommand|lockFile|verifyInstall>}}`, `{{kit.word.laneClosed}}`,
+ * `{{kit.board.<pattern|file|term>}}`, `{{kit.guard.<selfMerge|selfMergeLabel>}}`, `{{kit.merge.withoutChecks}}`, `{{kit.heading.<key>}}` from the plan
+ * vocabulary, the two languages, `{{kit.responseAddress}}`, the plan and worktree directory and the base branch. Other
  * `{{…}}` text is left alone; an unknown `kit.` placeholder throws rather than reaching a project
  * file unrendered. `overrides` win over the config: a global kit renders what each repository decides as
  * `<name>` (`REPOSITORY_TOKENS`).

package/src/sync/sync.ts

@@ -1,5 +1,5 @@
 import { homedir } from 'node:os'
-import { join } from 'node:path'
+import { basename, dirname, join } from 'node:path'
 import { CLAUDE_DIRECTORY, SETTINGS_FILE } from '../claude/paths'
 import type { JackherdConfig } from '../config'
 import type { RepositoryFacts } from '../config/detect'
@@ -7,19 +7,22 @@ import { CONFIG_FILE, MANIFEST_FILE, TOOL_DIRECTORY } from '../config/location'
 import { readRepositoryFacts } from '../config/repository-facts'
 import { REPOSITORY_TOKENS } from '../config/repository-values'
 import { CLI_NAME } from '../version/release'
+import { emptiedDirectories } from './emptied-directories'
 import { ensureGitignoreLines } from './gitignore'
 import { toGlobalKit, toProjectKit } from './global-kit'
 import type { KitSource } from './kit'
 import { kitNewPath, toolRootPath } from './kit-path'
 import { moveGlobalLegacyFiles, moveProjectLegacyFiles, removeEmptyLegacyDirectories } from './legacy-files'
 import { EMPTY_MANIFEST, type Manifest, parseManifest, serializeManifest } from './manifest'
-import { FILE_MODE, type FileEffect, type FilePlan, planFile, type RenderedFile } from './plan-file'
+import { FILE_MODE, FILE_OUTCOME, type FileEffect, type FilePlan, planFile, type RenderedFile } from './plan-file'
 import { type HooksPlan, planHooks } from './plan-hooks'
 import {
   assertNotHomeDirectory,
   assertOwnDirectoriesInProject,
+  DIRECTORY_OUTCOME,
   readLocalState,
   readRegularFile,
+  removeEmptyDirectory,
   removeFileSafely,
   writeFileSafely,
 } from './project-fs'
@@ -225,6 +228,21 @@ const applyHooks = async (claudeDirectory: string, hooks: HooksPlan): Promise<vo
   if (hooks.kitNew.kind === 'remove') await removeFileSafely(claudeDirectory, SETTINGS_KIT_NEW)
 }
 
+/** Takes away the empty directories the removed kit files left; one that holds anything else stays and is named. Housekeeping only: a directory it cannot remove is a note, never a failed sync. */
+const cleanUpDirectories = async (locate: Locate, plan: SyncPlan): Promise<string[]> => {
+  const removed = plan.files.filter(({ outcome }) => outcome === FILE_OUTCOME.removed).map(({ path }) => path)
+  const notes: string[] = []
+  for (const path of emptiedDirectories(removed, Object.keys(plan.manifest.files))) {
+    // A directory is located through a file below it, the one thing `Locate` knows how to place.
+    const { directory, path: target } = locate(`${path}/entry`)
+    const name = `${basename(directory)}/${dirname(target)}`
+    const outcome = await removeEmptyDirectory(directory, dirname(target)).catch(() => null)
+    if (outcome === null) notes.push(`Could not remove ${name}; remove it by hand if it is empty.`)
+    if (outcome === DIRECTORY_OUTCOME.notEmpty) notes.push(`Kept ${name}: it holds files the kit did not write.`)
+  }
+  return notes
+}
+
 /**
  * The manifest is written last: a run that dies halfway leaves files whose content equals the
  * kit version, which the next run adopts as unchanged instead of mistaking them for local edits.
@@ -232,12 +250,14 @@ const applyHooks = async (claudeDirectory: string, hooks: HooksPlan): Promise<vo
 const applyPlan = async (
   { claudeDirectory, toolDirectory, locate }: Pick<PlanInput, 'claudeDirectory' | 'toolDirectory' | 'locate'>,
   plan: SyncPlan,
-): Promise<void> => {
+): Promise<string[]> => {
   for (const { path, effect } of effectsInOrder(plan.files)) await applyFileEffect(locate, path, effect)
+  const notes = await cleanUpDirectories(locate, plan)
   await applyHooks(claudeDirectory, plan.hooks)
   const manifestText = serializeManifest(plan.manifest)
   if (manifestText !== plan.manifestText)
     await writeFileSafely(toolDirectory, MANIFEST_FILE, manifestText, FILE_MODE.regular)
+  return notes
 }
 
 const syncResultOf = (plan: SyncPlan): SyncResult => ({
@@ -266,11 +286,9 @@ export const syncProjectWithConfig = async (request: SyncRequest): Promise<Confi
     accept: request.accept,
     readHooks: projectHooks(claudeDirectory, request.kit, config),
   })
-  if (!request.check) {
-    await applyPlan(directories, plan)
-    await ensureGitignoreLines(request.projectRoot)
-  }
-  return { result: { ...syncResultOf(plan), notes: [...moved, ...notes] }, config }
+  const keptDirectoryNotes = request.check ? [] : await applyPlan(directories, plan)
+  if (!request.check) await ensureGitignoreLines(request.projectRoot)
+  return { result: { ...syncResultOf(plan), notes: [...moved, ...notes, ...keptDirectoryNotes] }, config }
 }
 
 export const runSync = async (request: SyncRequest): Promise<SyncResult> =>
@@ -302,9 +320,9 @@ export const syncGlobalWithConfig = async (request: GlobalSyncRequest): Promise<
     readHooks: noHooks,
     overrides: REPOSITORY_TOKENS,
   })
-  await applyPlan(directories, plan)
+  const keptDirectoryNotes = await applyPlan(directories, plan)
   await removeEmptyLegacyDirectories(claudeDirectory)
-  return { result: { ...syncResultOf(plan), notes: moved }, config }
+  return { result: { ...syncResultOf(plan), notes: [...moved, ...keptDirectoryNotes] }, config }
 }
 
 export const runGlobalSync = async (request: GlobalSyncRequest): Promise<SyncResult> =>

package/src/vocabulary/index.ts

@@ -8,6 +8,26 @@ export const LANGUAGE_NAME: Record<PlanLanguage, string> = {
   [PLAN_LANGUAGE.de]: 'German',
 }
 
+export const RESPONSE_ADDRESS = { informal: 'informal', formal: 'formal' } as const
+
+export type ResponseAddress = (typeof RESPONSE_ADDRESS)[keyof typeof RESPONSE_ADDRESS]
+
+/**
+ * How a skill's reply addresses the user, as the words a kit rule gives the agent. German and the other languages
+ * that tell a familiar from a polite "you" name the pronoun and the possessive; English has one form and only
+ * differs in tone.
+ */
+export const ADDRESS_FORM: Record<PlanLanguage, Record<ResponseAddress, string>> = {
+  [PLAN_LANGUAGE.en]: {
+    [RESPONSE_ADDRESS.informal]: 'the plain, direct “you”, without titles',
+    [RESPONSE_ADDRESS.formal]: 'a polite, businesslike “you”',
+  },
+  [PLAN_LANGUAGE.de]: {
+    [RESPONSE_ADDRESS.informal]: 'the familiar “du” (du, dir, dein), never “Sie”',
+    [RESPONSE_ADDRESS.formal]: 'the polite “Sie” (Sie, Ihnen, Ihr), never “du”',
+  },
+}
+
 /**
  * The option of the pull request question that approves the PR and a merge by the coordinator once the checks are
  * green. The merge guard hook matches the user's answer against this exact text, so it is fixed per language and not
@@ -59,6 +79,8 @@ export type PlanVocabulary = {
   noReviewGate: string
   /** Marks a lane as closed when its name cell contains it. */
   laneClosed: string
+  /** Words a starts-after cell begins with when the lane may start at once. */
+  startsNow: readonly string[]
   /** Words that may stand between two phases of one entry (`P1 Rule und P2 Monitor`). */
   phaseConnectors: readonly string[]
   statusWords: Record<PlanStatus, StatusWord>
@@ -82,6 +104,7 @@ export const PLAN_VOCABULARY: Record<PlanLanguage, PlanVocabulary> = {
     phase: 'Phase',
     noReviewGate: 'Kein Review-Gate',
     laneClosed: 'abgeräumt',
+    startsNow: ['sofort'],
     phaseConnectors: ['danach', 'und', 'dann', 'sowie'],
     statusWords: {
       done: { label: 'Done', leading: ['done'], anywhere: ['abgeschlossen'] },
@@ -109,6 +132,7 @@ export const PLAN_VOCABULARY: Record<PlanLanguage, PlanVocabulary> = {
     phase: 'Phase',
     noReviewGate: 'No review gate',
     laneClosed: 'cleaned up',
+    startsNow: ['now', 'immediately'],
     phaseConnectors: ['then', 'and', 'after'],
     statusWords: {
       done: { label: 'Done', leading: ['done'], anywhere: ['completed'] },

package/src/watch/command.ts

@@ -46,6 +46,7 @@ import { clockLocaleOf, type PlansSettings, plansSettingsOf, worktreeOf } from '
 import { boardTexts } from '../plans/texts'
 import { defaultUpdateCheck } from '../sync/if-changed'
 import { herdrLaneStatusSource } from '../terminal/herdr'
+import { AGENT_STATUS } from '../terminal/types'
 import { startedKit } from '../version/started-kit'
 import {
   type CoordinatorRead,
@@ -68,6 +69,7 @@ import {
 } from './feedback'
 import { type FeedbackItemsRead, readCommentItems, readFeedbackItems, readOwnLogin } from './feedback-read'
 import { answered, deployTargetOf, type GithubRead, readGithub, targetText } from './github-read'
+import { currentPhaseCountsOf, type PhaseCount, progressNotes } from './heartbeat-progress'
 import { agentScreen, listAgents } from './herdr'
 import { endedByKitUpdate } from './kit-update'
 import { type LaneReadings, laneFillEvents, recordLaneLevels } from './lane-fill'
@@ -216,6 +218,8 @@ type Watching = {
   state: WatchState
   baseline: LaneSnapshot
   current: LaneSnapshot
+  /** The phase count of each lane at the last heartbeat, so a heartbeat names only a count that moved. */
+  heartbeatCounts: Record<string, PhaseCount>
   /** The last `herdr agent list` answer, kept for finding the coordinator by its pane. */
   agents: HerdrAgent[]
   github: GithubRead | null
@@ -762,6 +766,20 @@ const report = async (
   return shown
 }
 
+/**
+ * The heartbeat of a stream: one line, a working lane with its phase count when that moved since the last heartbeat.
+ * The plans are read only when a lane works; a board that cannot be read leaves the lines without a count, and the
+ * next report names the failure.
+ */
+const printStreamHeartbeat = async (watch: Watch, watching: Watching, now: number): Promise<void> => {
+  const working = watching.lanes.filter((lane) => watching.current[lane]?.status === AGENT_STATUS.working)
+  const { progress } = working.length > 0 ? await boardReadOrNote(watch, working) : { progress: {} }
+  const counts = currentPhaseCountsOf(progress)
+  const notes = progressNotes(watching.lanes, watching.current, counts, watching.heartbeatCounts)
+  watching.heartbeatCounts = { ...watching.heartbeatCounts, ...counts }
+  console.log(streamHeartbeatLine(clock(watch, now), watching.lanes, watching.current, notes))
+}
+
 /**
  * One poll: reports what is due and tells whether to keep watching. Without `--stream` the first
  * report ends the watch; in a stream every reported lane counts as seen and the heartbeat is one line.
@@ -784,7 +802,7 @@ const pollOnce = async (watch: Watch, watching: Watching): Promise<boolean> => {
   } else if (heartbeat && !stream) {
     next = await report(watch, watching, [], [{ kind: WATCH_EVENT.heartbeat }], { ...next, statusLines: null })
   } else {
-    if (heartbeat) console.log(streamHeartbeatLine(clock(watch, now), watching.lanes, watching.current))
+    if (heartbeat) await printStreamHeartbeat(watch, watching, now)
     if (due) writePrivate(watch.files.state, JSON.stringify(next))
     watching.baseline = advanceBaseline(watching.baseline, watching.current)
   }
@@ -809,6 +827,7 @@ const initialWatching = (
   agents: start.agents,
   github: null,
   laneBranches: {},
+  heartbeatCounts: {},
   githubReadAt: 0,
   coordinator: { name: watch.options.coordinator, read: null },
   herdrDown: false,

package/src/watch/heartbeat-progress.ts

@@ -0,0 +1,47 @@
+import { currentPhase, type LaneProgress, PHASE_ID_PREFIX, type PhaseProgress } from '../plan-format'
+import { AGENT_STATUS } from '../terminal/types'
+import type { LaneSnapshot } from './lane-watch'
+
+/** The current phase of a lane and how many of its checkboxes are ticked, as the plans view counts them. */
+export type PhaseCount = Pick<PhaseProgress, 'id' | 'done' | 'total'>
+
+/** What a heartbeat adds to a working lane, by lane name: `P12 7/12`, without the middle dot of `shortTitle`, which the heartbeat's separator rewrite would turn into a slash. */
+export type LaneNotes = Readonly<Record<string, string>>
+
+/** The count of the lane's current phase; null without a plan, without a current phase or with nothing to tick. */
+export const currentPhaseCountOf = (progress: LaneProgress | null): PhaseCount | null => {
+  const phase = progress ? currentPhase(progress) : null
+  return phase && phase.total > 0 ? { id: phase.id, done: phase.done, total: phase.total } : null
+}
+
+/** The counts of the lanes that have one. */
+export const currentPhaseCountsOf = (progress: Readonly<Record<string, LaneProgress>>): Record<string, PhaseCount> =>
+  Object.fromEntries(
+    Object.entries(progress).flatMap(([lane, laneProgress]) => {
+      const count = currentPhaseCountOf(laneProgress)
+      return count ? [[lane, count]] : []
+    }),
+  )
+
+const sameCount = (left: PhaseCount | undefined, right: PhaseCount): boolean =>
+  left?.id === right.id && left.done === right.done && left.total === right.total
+
+/**
+ * The note of each working lane whose count differs from the one at the last heartbeat (or has none before): a lane
+ * that has not moved says nothing, so a stretch on one number tells the coordinator to look for itself.
+ */
+export const progressNotes = (
+  lanes: readonly string[],
+  current: LaneSnapshot,
+  counts: Readonly<Record<string, PhaseCount>>,
+  previous: Readonly<Record<string, PhaseCount>>,
+): LaneNotes =>
+  Object.fromEntries(
+    lanes.flatMap((lane) => {
+      const count = counts[lane]
+      const moved = count !== undefined && !sameCount(previous[lane], count)
+      return moved && current[lane]?.status === AGENT_STATUS.working
+        ? [[lane, `${PHASE_ID_PREFIX}${count.id} ${count.done}/${count.total}`]]
+        : []
+    }),
+  )

package/src/watch/source-command.ts

@@ -0,0 +1,16 @@
+import { basename } from 'node:path'
+
+const BUN_NAMES = new Set(['bun', 'bun.exe'])
+
+/**
+ * The command a source starts. The watcher starts it without a shell, so `bun` would be looked up on the PATH, where
+ * Bun may be missing although the watcher itself runs under it (installed in `~/.bun/bin` only). `bun` as the program
+ * therefore means the Bun that runs the watcher (`execPath`); a path written out, another program, or a watcher that
+ * runs under something else is left as written.
+ */
+export const resolveSourceCommand = (command: readonly string[], execPath: string): string[] => {
+  const [program, ...rest] = command
+  return program === 'bun' && BUN_NAMES.has(basename(execPath.replaceAll('\\', '/')))
+    ? [execPath, ...rest]
+    : [...command]
+}

package/src/watch/source-run.ts

@@ -1,3 +1,4 @@
+import { resolveSourceCommand } from './source-command'
 import { exitFailure, parseSourceOutput, SOURCE_FAILURE, type SourceRun, type SourceSettings } from './sources'
 
 /** How long a source's command may run and how much it may print before it is stopped. */
@@ -39,7 +40,13 @@ const readCapped = async (child: Child, maxBytes: number): Promise<string | null
 /** Started in a process group of its own, so a timeout reaches what the command started too (`curl` behind `sh`). */
 const spawned = (command: readonly string[], cwd: string): Child | null => {
   try {
-    return Bun.spawn([...command], { cwd, stdin: 'ignore', stdout: 'pipe', stderr: 'ignore', detached: true })
+    return Bun.spawn(resolveSourceCommand(command, process.execPath), {
+      cwd,
+      stdin: 'ignore',
+      stdout: 'pipe',
+      stderr: 'ignore',
+      detached: true,
+    })
   } catch {
     return null
   }

package/src/watch/stream-output.ts

@@ -1,14 +1,31 @@
 import { terminalSafe } from '../plan-format/terminal-text'
+import { AGENT_STATUS } from '../terminal/types'
+import type { LaneNotes } from './heartbeat-progress'
 import { type LaneSnapshot, NO_AGENT } from './lane-watch'
 import { WATCH_EVENT } from './watch-events'
 
+const SEPARATOR = ' · '
+
+/** `lane status`, a working lane with its note: `lane working: P12 7/12`. */
+const laneState = (lane: string, current: LaneSnapshot, notes: LaneNotes): string => {
+  const status = current[lane]?.status ?? NO_AGENT
+  const note = status === AGENT_STATUS.working ? notes[lane] : undefined
+  const head = `${terminalSafe(lane)} ${terminalSafe(status)}`
+  return note === undefined ? head : `${head}: ${terminalSafe(note).replaceAll(SEPARATOR, ' / ')}`
+}
+
 /**
  * The heartbeat of a stream, as one line, since every line of a stream reaches the coordinator as a
  * message of its own: `=== heartbeat <time> · <lane> <status> · …`.
  */
-export const streamHeartbeatLine = (time: string, lanes: readonly string[], current: LaneSnapshot): string => {
-  const states = lanes.map((lane) => `${terminalSafe(lane)} ${terminalSafe(current[lane]?.status ?? NO_AGENT)}`)
+export const streamHeartbeatLine = (
+  time: string,
+  lanes: readonly string[],
+  current: LaneSnapshot,
+  notes: LaneNotes,
+): string => {
+  const states = lanes.map((lane) => laneState(lane, current, notes))
   return [`=== ${WATCH_EVENT.heartbeat} ${terminalSafe(time)}`, ...(states.length > 0 ? states : ['no lanes'])].join(
-    ' · ',
+    SEPARATOR,
   )
 }