jackherd 1.14.0 → 1.15.0

package/src/sync/global-kit.ts

@@ -1,7 +1,8 @@
-import { AGENTS_DIRECTORY, claudePath, RULES_DIRECTORY, SKILLS_DIRECTORY } from '../claude/paths'
+import { AGENT_PATH, claudePath, prefixedKitPath, RULES_DIRECTORY, SKILL_PATH, SKILLS_DIRECTORY } from '../claude/paths'
 import { SKILL_PREFIX } from '../config'
 import { TOOL_DIRECTORY } from '../config/location'
 import { REPOSITORY_TOKENS } from '../config/repository-values'
+import { escapeRegExp } from '../plan-format/markdown'
 import { CLI_NAME, PACKAGE_NAME } from '../version/release'
 import type { KitFile, KitSource } from './kit'
 import { TOOL_ROOT } from './kit-path'
@@ -15,8 +16,6 @@ const GLOBAL_RULES_DIRECTORY = `${TOOL_ROOT}/${RULES_DIRECTORY}`
 /** Put at the top of a global file that names values each repository decides; `sync --global` renders them as `<name>`. */
 export const REPOSITORY_VALUES_NOTE = `Values in angle brackets such as \`<test>\`, \`<install>\` or \`<baseBranch>\` are the current repository's own: run \`${CLI_NAME} config\` once in it to read them all, or \`${CLI_NAME} config <name>\` for one.`
 
-const SKILL_PATH = new RegExp(`^${SKILLS_DIRECTORY}/([^/]+)/(.+)$`)
-const AGENT_PATH = new RegExp(`^${AGENTS_DIRECTORY}/([^/]+)\\.md$`)
 const SKILL_ENTRY = new RegExp(`^${SKILLS_DIRECTORY}/[^/]+/SKILL\\.md$`)
 const RULE_PATH = new RegExp(`^${RULES_DIRECTORY}/kit/(.+)$`)
 
@@ -24,8 +23,6 @@ const FRONTMATTER = /^---\n([\s\S]*?)\n---\n/
 const NAME_LINE = /^name: (.+)$/m
 const DESCRIPTION_LINE = /^description: '(.*)'$/m
 
-const escapeRegExp = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-
 export const globalNote = (name: string, kind: EntryKind): string =>
   `Global ${PACKAGE_NAME} copy. In a project that has its own ${name} ${kind}, use that one instead. `
 
@@ -38,20 +35,12 @@ const assertUsablePrefix = (prefix: string): void => {
 /** Where the status line lands: `~/.jackherd/statusline.sh`; `init --global` offers it from there. */
 const GLOBAL_STATUS_LINE_PATH = `${TOOL_ROOT}/statusline.sh`
 
-/** The path in a project's `.claude/`: skills and agents prefixed, everything else where the kit puts it. */
-const projectPath = (path: string, prefix: string): string => {
-  const skill = SKILL_PATH.exec(path)
-  if (skill) return `${SKILLS_DIRECTORY}/${prefix}${skill[1]}/${skill[2]}`
-  const agent = AGENT_PATH.exec(path)
-  return agent ? `${AGENTS_DIRECTORY}/${prefix}${agent[1]}.md` : path
-}
-
 /** The path in `~/.claude`, or null for what stays out of a global install (the hooks). */
 const globalPath = (path: string, prefix: string): string | null => {
   if (path === 'statusline.sh') return GLOBAL_STATUS_LINE_PATH
   const rule = RULE_PATH.exec(path)
   if (rule) return `${GLOBAL_RULES_DIRECTORY}/${rule[1]}`
-  return SKILL_PATH.test(path) || AGENT_PATH.test(path) ? projectPath(path, prefix) : null
+  return SKILL_PATH.test(path) || AGENT_PATH.test(path) ? prefixedKitPath(path, prefix) : null
 }
 
 const entryKind = (path: string): EntryKind | null => {
@@ -69,16 +58,37 @@ const kitNames = (files: KitFile[]): string[] => {
   return [...new Set(names)].sort((left, right) => right.length - left.length)
 }
 
-/** Names as a skill or agent calls another: slash commands, `subagent_type`, backticked names, relative links. */
-const rewriteNames = (text: string, alternation: string, prefix: string): string =>
+/**
+ * Names as a skill or agent calls another: slash commands, `subagent_type`, backticked names. `rename` gives the new
+ * name inside the call, `suffix` follows the whole call, after a closing quote or backtick.
+ */
+export const rewriteCalls = (
+  text: string,
+  alternation: string,
+  rename: (name: string) => string,
+  suffix = '',
+): string =>
   text
     .replace(
+      new RegExp(`(?<![\\w.~/-])/(${alternation})(?![\\w/-])`, 'g'),
+      (_call, name: string) => `/${rename(name)}${suffix}`,
+    )
+    .replace(
+      new RegExp(`subagent_type: '(${alternation})'`, 'g'),
+      (_call, name: string) => `subagent_type: '${rename(name)}'${suffix}`,
+    )
+    .replace(new RegExp(`\`(${alternation})\``, 'g'), (_call, name: string) => `\`${rename(name)}\`${suffix}`)
+
+/** The calls of `rewriteCalls` and relative links, each with the prefix. */
+const rewriteNames = (text: string, alternation: string, prefix: string): string =>
+  rewriteCalls(
+    text.replace(
       new RegExp(`\\.\\./${SKILLS_DIRECTORY}/(${alternation})(?![\\w-])`, 'g'),
       `../${SKILLS_DIRECTORY}/${prefix}$1`,
-    )
-    .replace(new RegExp(`(?<![\\w.~/-])/(${alternation})(?![\\w/-])`, 'g'), `/${prefix}$1`)
-    .replace(new RegExp(`subagent_type: '(${alternation})'`, 'g'), `subagent_type: '${prefix}$1'`)
-    .replace(new RegExp(`\`(${alternation})\``, 'g'), `\`${prefix}$1\``)
+    ),
+    alternation,
+    (name) => `${prefix}${name}`,
+  )
 
 const PROJECT_SKILLS = claudePath(SKILLS_DIRECTORY)
 const GLOBAL_SKILLS = `~/${PROJECT_SKILLS}`
@@ -151,7 +161,7 @@ export const toGlobalKit = (kit: KitSource, prefix: string): KitSource => {
 }
 
 const toProjectFile = (file: KitFile, names: string[], prefix: string): KitFile => {
-  const path = projectPath(file.path, prefix)
+  const path = prefixedKitPath(file.path, prefix)
   if (!file.path.endsWith('.md') || file.path.startsWith('hooks/')) return { ...file, path }
   const alternation = names.map(escapeRegExp).join('|')
   const body = rewriteNames(rewriteSkillPaths(file.template, alternation, prefix, PROJECT_SKILLS), alternation, prefix)

package/src/sync/init.ts

@@ -5,6 +5,7 @@ import { type JackherdConfig, parseJackherdConfig, type TerminalAdapter } from '
 import { type RepositoryFacts, STACKS, withDetected } from '../config/detect'
 import { CONFIG_FILE, CONFIG_SCHEMA_REFERENCE, TOOL_DIRECTORY } from '../config/location'
 import { readRepositoryFacts } from '../config/repository-facts'
+import { DEFAULT_SKILL_PREFIX } from '../config/schema'
 import type { KitSource } from './kit'
 import { moveGlobalLegacyFiles, moveProjectLegacyFiles } from './legacy-files'
 import { assertNotHomeDirectory, assertOwnDirectoriesInProject, createFileExclusively } from './project-fs'
@@ -35,8 +36,7 @@ export type InitResult = {
   terminalAdapter: TerminalAdapter
 }
 
-/** What a global install, and a project that already has skills of kit names, puts before every kit name. */
-export const DEFAULT_SKILL_PREFIX = 'jh-'
+export { DEFAULT_SKILL_PREFIX }
 
 const SKILL_ENTRY = new RegExp(`^${SKILLS_DIRECTORY}/([^/]+)/SKILL\\.md$`)
 const AGENT_ENTRY = new RegExp(`^${AGENTS_DIRECTORY}/([^/]+)\\.md$`)

package/src/sync/kit-exclude.ts

@@ -0,0 +1,39 @@
+import { AGENT_PATH, SKILL_PATH } from '../claude/paths'
+import { escapeRegExp } from '../plan-format/markdown'
+import { rewriteCalls } from './global-kit'
+import type { KitFile, KitSource } from './kit'
+
+/** The skill or agent a kit file belongs to, by its unprefixed name; null for rules, hooks and the status line. */
+const entryNameOf = ({ path }: KitFile): string | null => (SKILL_PATH.exec(path) ?? AGENT_PATH.exec(path))?.[1] ?? null
+
+/** Kit texts an agent reads; the hooks' Markdown and every script stay as the kit wrote them. */
+const isAgentText = ({ path }: KitFile): boolean => path.endsWith('.md') && !path.startsWith('hooks/')
+
+/**
+ * A call of an excluded name reads `/devops (not installed)`, so an agent sees the skill is missing instead of a dead
+ * call. Links and `.claude/skills/<name>/` paths stay as they are: a mark inside a path would break the link it is in.
+ */
+const markedNotInstalled = (file: KitFile, alternation: string): KitFile =>
+  isAgentText(file)
+    ? { ...file, template: rewriteCalls(file.template, alternation, (name) => name, ' (not installed)') }
+    : file
+
+/**
+ * The kit without the skills and agents `kit.exclude` names: a name takes its skill directory and its agent alike, and
+ * every call of it in the remaining texts is marked as not installed. Applied before `skillPrefix`, so the names are
+ * the kit's own. A name the kit has neither of throws, so a typo never reads as excluded.
+ */
+export const withoutExcluded = (kit: KitSource, exclude: readonly string[]): KitSource => {
+  if (exclude.length === 0) return kit
+  const known = new Set(kit.files.map(entryNameOf))
+  const unknown = exclude.filter((name) => !known.has(name))
+  if (unknown.length > 0) {
+    throw new Error(
+      `kit.exclude names no kit skill or agent: ${unknown.join(', ')}. Correct the name, or take it off the list if this kit version no longer ships it.`,
+    )
+  }
+  const excluded = new Set(exclude)
+  const alternation = exclude.map(escapeRegExp).join('|')
+  const files = kit.files.filter((file) => !excluded.has(entryNameOf(file) ?? ''))
+  return { ...kit, files: files.map((file) => markedNotInstalled(file, alternation)) }
+}

package/src/sync/plan-file.ts

@@ -80,7 +80,7 @@ const planKitDropped = (input: FileInput): FilePlan => {
   if (checksumOf(input.local) === input.entry.base) {
     return plan(input, FILE_OUTCOME.removed, [{ kind: 'remove', target: 'file' }, ...cleanUpKitNew(input)], undefined)
   }
-  return plan(input, FILE_OUTCOME.untracked, [], undefined)
+  return plan(input, FILE_OUTCOME.untracked, cleanUpKitNew(input), undefined)
 }
 
 const planConflict = (input: FileInput, rendered: RenderedFile): FilePlan => {

package/src/sync/render.ts

@@ -47,6 +47,7 @@ const placeholderValues = (config: JackherdConfig): Map<string, string> => {
     ...prefixed('guard.standingApproval', STANDING_APPROVAL_TEXTS[config.responseLanguage]),
     ...prefixed('approval', APPROVAL_TEXTS[config.responseLanguage]),
     ['kit.merge.withoutChecks', checkFreeList(config.merge.withoutChecks)],
+    ['kit.merge.openAsDraft', config.merge.openAsDraft ? 'on' : 'off'],
     ...prefixed('heading', { ...header, ...sections, ...columns, phase }),
   ])
 }
@@ -58,7 +59,7 @@ 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|verifyInstall>}}`, `{{kit.word.<laneClosed|openSubagents>}}`,
- * `{{kit.board.<pattern|file|term>}}`, `{{kit.guard.<selfMerge|selfMergeLabel>}}`, `{{kit.guard.standingApproval.<approve|until>}}`, `{{kit.merge.withoutChecks}}`, `{{kit.heading.<key>}}` from the plan
+ * `{{kit.board.<pattern|file|term>}}`, `{{kit.guard.<selfMerge|selfMergeLabel>}}`, `{{kit.guard.standingApproval.<approve|until>}}`, `{{kit.merge.<withoutChecks|openAsDraft>}}`, `{{kit.heading.<key>}}` from the plan
  * vocabulary, the two languages, `{{kit.responseAddress}}`, the plan and worktree directory and the base branch. A
  * command or lock file the config leaves unset renders as `unsetValueText`, never as a guessed default. Other
  * `{{…}}` text is left alone; an unknown `kit.` placeholder throws rather than reaching a project

package/src/sync/report.ts

@@ -1,4 +1,7 @@
+import { PROJECT_CONFIG_PATH } from '../config/location'
+import { DEFAULT_SKILL_PREFIX } from '../config/schema'
 import { CLI_NAME } from '../version/release'
+import { foreignSkillNamesOf, SKILLS_LOCK_FILE, skillEntryPath } from './foreign-skills'
 import { shownPath } from './kit-path'
 import { FILE_OUTCOME, type FileOutcome } from './plan-file'
 import { HOOK_OUTCOME, type HookOutcome } from './plan-hooks'
@@ -61,7 +64,7 @@ const FILE_SECTIONS: { outcome: FileOutcome; heading: string; line: (path: strin
   },
   {
     outcome: FILE_OUTCOME.untracked,
-    heading: 'No longer in the kit, kept with your changes and no longer tracked',
+    heading: 'No longer in the kit or excluded, kept with your changes and no longer tracked',
     line: (path) => `  ${shownPath(path)}`,
   },
   { outcome: FILE_OUTCOME.resolved, heading: 'Conflicts resolved', line: (path) => `  ${shownPath(path)}` },
@@ -78,6 +81,28 @@ const HOOK_SECTIONS: { outcome: HookOutcome; heading: string }[] = [
 
 const RESOLVE_HINT = `Resolve a conflict: merge the .kit-new into your file and delete it, or run \`${CLI_NAME} sync --accept <path>\` to take the kit version.`
 
+const FOREIGN_SKILL_HEADING = `A skill from ${SKILLS_LOCK_FILE} sits on the kit's path, your file was kept`
+
+/** A conflict, or a kept file: `npx skills add` overwrites the kit's file, and an unchanged kit reports it as kept. */
+const FOREIGN_SKILL_OUTCOMES: readonly FileOutcome[] = [FILE_OUTCOME.conflict, FILE_OUTCOME.kept]
+
+const foreignSkillHint = (names: readonly string[]): string =>
+  `  Set "skillPrefix": "${DEFAULT_SKILL_PREFIX}" in ${PROJECT_CONFIG_PATH} and run \`${CLI_NAME} sync\`: the kit moves to ${names.map((name) => `/${DEFAULT_SKILL_PREFIX}${name}`).join(', ')} and the foreign skill stays. Or install the skill as a plugin with its own namespace.`
+
+/**
+ * The lines for a kit skill that `skills-lock.json` lists and that sync kept or left in conflict, heading and the
+ * two ways out; empty when there is none. `foreign` is the set of skill names from that file.
+ */
+export const foreignSkillLines = (result: SyncResult, foreign: ReadonlySet<string>): string[] => {
+  const occupied = result.files
+    .filter(({ outcome }) => FOREIGN_SKILL_OUTCOMES.includes(outcome))
+    .map(({ path }) => path)
+  const names = foreignSkillNamesOf(occupied, foreign)
+  if (names.length === 0) return []
+  const lines = names.map((name) => `  ${shownPath(skillEntryPath(name))}`)
+  return ['', `${FOREIGN_SKILL_HEADING}:`, ...lines, foreignSkillHint(names)]
+}
+
 export const exitCodeOf = (result: SyncResult): number => {
   const outcomes = [...result.files, ...result.hooks].map(({ outcome }) => outcome)
   return outcomes.some((outcome) => NEEDS_ATTENTION.includes(outcome)) ? SYNC_EXIT.conflicts : SYNC_EXIT.clean
@@ -98,6 +123,9 @@ const summaryLine = (outcomes: Outcome[]): string => {
 
 const section = (heading: string, lines: string[]): string[] => (lines.length > 0 ? ['', `${heading}:`, ...lines] : [])
 
+const excludedLines = (excluded: readonly string[] = []): string[] =>
+  excluded.length > 0 ? ['', `Left out by kit.exclude: ${excluded.join(', ')}`] : []
+
 export const formatReport = (result: SyncResult): string => {
   const fileLines = FILE_SECTIONS.flatMap(({ outcome, heading, line }) =>
     section(
@@ -113,5 +141,12 @@ export const formatReport = (result: SyncResult): string => {
   )
   const hint = exitCodeOf(result) === SYNC_EXIT.conflicts ? ['', RESOLVE_HINT] : []
   const summary = summaryLine([...result.files, ...result.hooks].map(({ outcome }) => outcome))
-  return [...(result.notes ?? []), summary, ...fileLines, ...hookLines, ...hint].join('\n')
+  return [
+    ...(result.notes ?? []),
+    summary,
+    ...excludedLines(result.excluded),
+    ...fileLines,
+    ...hookLines,
+    ...hint,
+  ].join('\n')
 }

package/src/sync/sync-result.ts

@@ -5,5 +5,8 @@ export type FileReport = { path: string; outcome: FileOutcome }
 
 export type HookReport = { name: string; outcome: HookOutcome }
 
-/** `notes` name the config values the repository did not decide, printed before the summary. */
-export type SyncResult = { files: FileReport[]; hooks: HookReport[]; notes?: string[] }
+/**
+ * `notes` name the config values the repository did not decide, printed before the summary. `excluded` are the kit
+ * skills and agents `kit.exclude` left out, by the kit's name.
+ */
+export type SyncResult = { files: FileReport[]; hooks: HookReport[]; notes?: string[]; excluded?: string[] }

package/src/sync/sync.ts

@@ -12,6 +12,7 @@ import { emptiedDirectories } from './emptied-directories'
 import { ensureGitignoreLines } from './gitignore'
 import { toGlobalKit, toProjectKit } from './global-kit'
 import type { KitSource } from './kit'
+import { withoutExcluded } from './kit-exclude'
 import { kitNewPath, toolRootPath } from './kit-path'
 import { moveGlobalLegacyFiles, moveProjectLegacyFiles, removeEmptyLegacyDirectories } from './legacy-files'
 import { EMPTY_MANIFEST, type Manifest, parseManifest, serializeManifest } from './manifest'
@@ -297,9 +298,10 @@ const applyPlan = async (
   return notes
 }
 
-const syncResultOf = (plan: SyncPlan): SyncResult => ({
+const syncResultOf = (plan: SyncPlan, excluded: readonly string[]): SyncResult => ({
   files: plan.files.map(({ path, outcome }) => ({ path, outcome })),
   hooks: plan.hooks.outcomes,
+  ...(excluded.length > 0 ? { excluded: [...excluded] } : {}),
 })
 
 /**
@@ -319,7 +321,7 @@ export const syncProjectWithConfig = async (request: SyncRequest): Promise<Confi
   const directories = { claudeDirectory, toolDirectory, locate: inClaudeDirectory(claudeDirectory) }
   const plan = await buildPlan({
     ...directories,
-    kit: toProjectKit(request.kit, config.skillPrefix),
+    kit: toProjectKit(withoutExcluded(request.kit, config.kit.exclude), config.skillPrefix),
     config,
     accept: request.accept,
     readHooks: projectHooks(claudeDirectory, request.kit, config),
@@ -327,7 +329,10 @@ export const syncProjectWithConfig = async (request: SyncRequest): Promise<Confi
   const keptDirectoryNotes = request.check ? [] : await applyPlan(directories, plan)
   if (!request.check) await writeConfigRewrite(toolDirectory, read)
   if (!request.check) await ensureGitignoreLines(request.projectRoot)
-  return { result: { ...syncResultOf(plan), notes: [...moved, ...notes, ...keptDirectoryNotes] }, config }
+  return {
+    result: { ...syncResultOf(plan, config.kit.exclude), notes: [...moved, ...notes, ...keptDirectoryNotes] },
+    config,
+  }
 }
 
 export const runSync = async (request: SyncRequest): Promise<SyncResult> =>
@@ -354,7 +359,7 @@ export const syncGlobalWithConfig = async (request: GlobalSyncRequest): Promise<
   const directories = { claudeDirectory, toolDirectory, locate: inGlobalDirectories(claudeDirectory, toolDirectory) }
   const plan = await buildPlan({
     ...directories,
-    kit: toGlobalKit(request.kit, config.skillPrefix),
+    kit: toGlobalKit(withoutExcluded(request.kit, config.kit.exclude), config.skillPrefix),
     config,
     accept: request.accept,
     readHooks: noHooks,
@@ -363,7 +368,10 @@ export const syncGlobalWithConfig = async (request: GlobalSyncRequest): Promise<
   const keptDirectoryNotes = await applyPlan(directories, plan)
   await writeConfigRewrite(toolDirectory, read)
   await removeEmptyLegacyDirectories(claudeDirectory)
-  return { result: { ...syncResultOf(plan), notes: [...moved, ...read.notes, ...keptDirectoryNotes] }, config }
+  return {
+    result: { ...syncResultOf(plan, config.kit.exclude), notes: [...moved, ...read.notes, ...keptDirectoryNotes] },
+    config,
+  }
 }
 
 export const runGlobalSync = async (request: GlobalSyncRequest): Promise<SyncResult> =>

package/src/task-signals/claude-signals.ts

@@ -1,3 +1,4 @@
+import { CLAUDE_TOOL, CONTENT_BLOCK_TYPE } from '../context/log-vocabulary'
 import { parseLogEntry } from '../context/session-log'
 import { isRecord } from '../shared/is-record'
 import { cleanTaskText } from './text'
@@ -76,9 +77,9 @@ const onTodoWrite = (tracker: Tracker, input: Record<string, unknown>): void =>
 const onToolUse = (tracker: Tracker, block: Block): void => {
   const input = block.input
   if (!isRecord(input)) return
-  if (block.name === 'TaskCreate' && typeof block.id === 'string') tracker.pending.set(block.id, input)
-  if (block.name === 'TaskUpdate') onTaskUpdate(tracker, input)
-  if (block.name === 'TodoWrite') onTodoWrite(tracker, input)
+  if (block.name === CLAUDE_TOOL.taskCreate && typeof block.id === 'string') tracker.pending.set(block.id, input)
+  if (block.name === CLAUDE_TOOL.taskUpdate) onTaskUpdate(tracker, input)
+  if (block.name === CLAUDE_TOOL.todoWrite) onTodoWrite(tracker, input)
 }
 
 const visit = (tracker: Tracker, entry: Record<string, unknown>): void => {
@@ -86,8 +87,8 @@ const visit = (tracker: Tracker, entry: Record<string, unknown>): void => {
   if (!Number.isNaN(time)) tracker.time = time
   if (typeof entry.cwd === 'string') tracker.cwd = entry.cwd
   for (const block of blocksOf(entry)) {
-    if (block.type === 'tool_use') onToolUse(tracker, block)
-    if (block.type === 'tool_result') onResult(tracker, entry, block)
+    if (block.type === CONTENT_BLOCK_TYPE.toolUse) onToolUse(tracker, block)
+    if (block.type === CONTENT_BLOCK_TYPE.toolResult) onResult(tracker, entry, block)
   }
 }
 

package/src/watch/command.ts

@@ -95,7 +95,14 @@ import { type LaneReadings, laneFillEvents, recordLaneLevels } from './lane-fill
 import { laneMessage, rememberedStatusLines, statusBlock } from './lane-message'
 import { type LaneModelReading, laneModelEvents, recordLaneModels } from './lane-model'
 import { laneParallelEvents, recordLaneParallels } from './lane-parallel'
-import { boardCheckoutRows, watchedLaneParallel, watchedLaneProgress, watchedPlanPullRequests } from './lane-progress'
+import {
+  boardCheckoutRows,
+  watchedLaneParallel,
+  watchedLaneProgress,
+  watchedPlanPullRequests,
+  watchedReadyPhases,
+  workedPhaseKeys,
+} from './lane-progress'
 import {
   appointmentEventLine,
   approvalDutyLines,
@@ -114,6 +121,8 @@ import {
   otherPullRequestsLine,
   parallelDutyLines,
   planMissingDutyLines,
+  type ReadyPhase,
+  readyPhaseDutyLines,
   sourceEventLines,
   sourceFailingStatusLine,
   watchEventLine,
@@ -556,12 +565,14 @@ const laneReportOf = (
   }
 }
 
+type BoardReadOrNote = { progress: Record<string, LaneProgress>; checkoutRows: number; notes: string[] }
+
 /** `boardReadOf`, or when the board cannot be read, nothing of it and a note that says why. */
 const boardReadOrNote = async (
   watch: Watch,
   lanes: readonly string[],
   pullRequests: readonly WatchedPullRequest[],
-): Promise<{ progress: Record<string, LaneProgress>; checkoutRows: number; notes: string[] }> => {
+): Promise<BoardReadOrNote> => {
   try {
     return { ...(await boardReadOf(watch, lanes, pullRequests)), notes: [] }
   } catch (error) {
@@ -577,15 +588,15 @@ const boardReadOrNote = async (
  * The lane lines of the status block, the coordinator's line, the line of the own pull requests without a lane that
  * follows it (`others`), and the lines after the block (notes, a gh outage).
  */
-const statusLinesOf = async (
+const statusLinesOf = (
   watch: Watch,
   watching: Watching,
   state: WatchState,
-): Promise<{ laneLines: string[]; coordinator: string; others: string[]; rest: string[] }> => {
+  { progress, checkoutRows, notes }: BoardReadOrNote,
+): { laneLines: string[]; coordinator: string; others: string[]; rest: string[] } => {
   const github = answered(watching.github)
   const pullRequests = github?.pullRequests ?? []
   const others = otherPullRequestsLine(pullRequests, github?.own ?? [], watch.texts)
-  const { progress, checkoutRows, notes } = await boardReadOrNote(watch, watching.lanes, pullRequests)
   const closeLaneHint = hintFor(watch, REFERENCE.closeLane)
   const laneLines = watching.lanes.map((lane) =>
     laneReportLine(
@@ -648,6 +659,19 @@ const mainCheckoutLineAfter = async (
   return mainCheckoutLineOf(watch)
 }
 
+/** The ready phases of the stopped lanes that rest (`done`, `idle`); only their plans are read. */
+const readyPhasesOfResting = (
+  watch: Watch,
+  watching: Watching,
+  stopped: readonly string[],
+  progress: Readonly<Record<string, LaneProgress>>,
+): Record<string, ReadyPhase[]> => {
+  const resting = stopped.filter((lane) => IDLE_STATUSES.has(watching.current[lane]?.status ?? ''))
+  if (resting.length === 0) return {}
+  const lanes = (readSprintLanes(watch) ?? []).filter((lane) => resting.includes(lane.name))
+  return watchedReadyPhases(watch.root, watch.settings, watch.sprintFile, lanes, workedPhaseKeys(progress))
+}
+
 /**
  * Every line of one return, gathered before any is printed, so the output is never cut halfway by a slow lookup, and
  * the state with what it showed: the report times of the stopped lanes and the status lines. A state without status
@@ -663,8 +687,11 @@ const reportOf = async (
   const stops = stoppedLaneSections(watch, watching, stopped, next)
   const eventLines = await eventLinesOf(watch, events, watching.github)
   const mainCheckout = await mainCheckoutLineAfter(watch, watching, events)
+  const board = await boardReadOrNote(watch, watching.lanes, answered(watching.github)?.pullRequests ?? [])
+  const ready = readyPhasesOfResting(watch, watching, stopped, board.progress)
   const dutyLines = [
     ...blockedDutyLines(stopped, watching.current, watch.texts),
+    ...readyPhaseDutyLines(stopped, watching.current, ready, watch.texts),
     ...mergeDutyLines(events, watching.lanes, watch.texts),
     ...(mainCheckout === null ? [] : [mainCheckout]),
     ...laneFillDutyLines(events, watch.texts),
@@ -674,7 +701,7 @@ const reportOf = async (
     ...planMissingDutyLines(events, watch.texts),
     ...approvalDutyLines(events, watch.texts),
   ]
-  const status = await statusLinesOf(watch, watching, next)
+  const status = statusLinesOf(watch, watching, next, board)
   const block = statusBlock(status.laneLines, status.coordinator, next.statusLines, status.others)
   const shownReports = stopped.filter((lane) => stops.reportMtimes[lane] !== next.reportMtimes[lane])
   return {
@@ -1350,7 +1377,8 @@ const saveState = (watch: Watch, watching: Watching) => {
   writePrivateFile(watch.files.state, JSON.stringify(unread ? watching.state : recordedOf(watch, watching)))
 }
 
-const watchLanes = async (watch: Watch) => {
+/** Watches until the lanes end or the kit changes on disk; true when a kit update ended it. */
+const watchLanes = async (watch: Watch): Promise<boolean> => {
   const takeOver = await takeOverLock(watch.files.lock)
   const state = await readState(watch.files)
   const agents = listAgents()
@@ -1389,8 +1417,9 @@ const watchLanes = async (watch: Watch) => {
       await Bun.sleep(POLL_MS)
       pollLanes(watch, watching)
       await announceUpdate?.()
-      if (endedByKitUpdate(kit, effects)) return
+      if (endedByKitUpdate(kit, effects)) return true
     }
+    return false
   } finally {
     sourceChanges?.close()
     stopPublisher?.()
@@ -1456,6 +1485,20 @@ const watchOf = (options: WatchOptions): Watch => {
   }
 }
 
+/** How a watch ended: the kit's source changed under it, or the loop stopped with an exit code. */
+type WatchEnd = { kind: 'kitUpdated' } | { kind: 'stopped'; code: number }
+
+const watchToEnd = async (watch: Watch): Promise<WatchEnd> => {
+  try {
+    return (await watchLanes(watch)) ? { kind: 'kitUpdated' } : { kind: 'stopped', code: 0 }
+  } catch (error) {
+    console.log(`watcher stopped: ${errorText(error)}`)
+    return { kind: 'stopped', code: 1 }
+  } finally {
+    releaseLock(watch.files.lock)
+  }
+}
+
 export const run = async (args: string[]): Promise<number> => {
   let options: WatchOptions
   try {
@@ -1480,13 +1523,9 @@ export const run = async (args: string[]): Promise<number> => {
     console.error(errorText(error))
     return 1
   }
-  try {
-    await watchLanes(watch)
-    return 0
-  } catch (error) {
-    console.log(`watcher stopped: ${errorText(error)}`)
-    return 1
-  } finally {
-    releaseLock(watch.files.lock)
-  }
+  const end = await watchToEnd(watch)
+  // The loop's timers and child handles outlive it, so the process would stay beside the watcher that replaces it;
+  // the state is saved and the lock released, as on SIGTERM.
+  if (end.kind === 'kitUpdated') process.exit(0)
+  return end.code
 }

package/src/watch/lane-message.ts

@@ -1,5 +1,5 @@
 import { terminalSafe } from '../plan-format/terminal-text'
-import { AGENT_STATUS } from './lane-watch'
+import { AGENT_STATUS } from '../terminal/types'
 import { budgetQuestions, questionCount, questionSections } from './report-questions'
 
 /** A lane's report file as the watcher found it: its path, when it was last written, its text. */

package/src/watch/lane-progress.ts

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
-import { type LaneProgress, parallelGroupsOfPlan, resolvePlanPath, type SprintLane } from '../plan-format'
+import { currentPhase, type LaneProgress, parallelGroupsOfPlan, resolvePlanPath, type SprintLane } from '../plan-format'
 import { boardRowsOf } from '../plans/board-rows'
 import { type BaseReader, baseReaderOf, gitStatusOf } from '../plans/git'
 import { laneWorkOf, readPlans, textAtBase } from '../plans/lane-plans'
@@ -8,6 +8,7 @@ import { laneHeads, type PlanPullRequest, planPullRequests } from '../plans/plan
 import { baseRefOf, boardRepoPathOf, type PlansSettings, worktreeOf } from '../plans/settings'
 import { workedLaneProgress } from '../plans/worked-phases'
 import { parallelBatchOf } from './lane-parallel'
+import { type ReadyPhase, readyPhasesOf } from './lane-report'
 import { PULL_REQUEST_STATE, type WatchedPullRequest } from './pull-requests'
 
 /** The open pull requests of the watcher's list that change a plan, as the herd chooses them. */
@@ -47,6 +48,10 @@ export const watchedLaneProgress = async (
   return workedLaneProgress(lane, plans)
 }
 
+/** The plan link of a lane's newest row that links one, as the board spells it; null without such a row. */
+const newestPlanHref = (lane: SprintLane): string | null =>
+  lane.steps.filter((step) => step.planHref !== null).at(-1)?.planHref ?? null
+
 /** The repository path of the plan of a lane's newest row that links one; null without such a row. */
 export const lanePlanPath = (
   root: string,
@@ -54,7 +59,7 @@ export const lanePlanPath = (
   boardFile: string,
   lane: SprintLane,
 ): string | null => {
-  const href = lane.steps.filter((step) => step.planHref !== null).at(-1)?.planHref
+  const href = newestPlanHref(lane)
   return href ? resolvePlanPath(dirname(boardRepoPathOf(root, settings, boardFile)), href) : null
 }
 
@@ -102,6 +107,50 @@ export const watchedLaneParallel = (
   return groups === null ? [] : parallelBatchOf(groups)
 }
 
+/** A phase the lanes work on, keyed by its plan link as the board spells it, since two plans may share an id. */
+const workedPhaseKey = (planHref: string, id: string): string => `${planHref}#${id}`
+
+/** The ids of the phases in the plan of `planHref` that a lane works on, out of `workedPhaseKeys`. */
+const phaseIdsWorkedIn = (worked: ReadonlySet<string>, planHref: string): Set<string> => {
+  const prefix = workedPhaseKey(planHref, '')
+  return new Set([...worked].flatMap((key) => (key.startsWith(prefix) ? [key.slice(prefix.length)] : [])))
+}
+
+/** The phases the lanes work on: the current phase of each lane's progress that has one, with its plan link. */
+export const workedPhaseKeys = (progress: Readonly<Record<string, LaneProgress>>): Set<string> =>
+  new Set(
+    Object.values(progress).flatMap((each) => {
+      const phase = currentPhase(each)
+      const planHref = each.current === null ? null : each.steps[each.current.stepIndex]?.step.planHref
+      return phase && planHref ? [workedPhaseKey(planHref, phase.id)] : []
+    }),
+  )
+
+/**
+ * Per lane, the open phases of its plan whose dependencies are all ticked off and that no lane works on (`worked`, from
+ * `workedPhaseKeys`), by the plan's dependency table and ticks, as the lane's worktree has them; empty for a lane
+ * without a readable plan.
+ */
+export const watchedReadyPhases = (
+  root: string,
+  settings: PlansSettings,
+  boardFile: string,
+  lanes: readonly SprintLane[],
+  worked: ReadonlySet<string>,
+): Record<string, ReadyPhase[]> =>
+  Object.fromEntries(
+    lanes.map((lane) => {
+      const planHref = newestPlanHref(lane)
+      const text = watchedLanePlanText(root, settings, boardFile, lane)
+      return [
+        lane.name,
+        text === null || planHref === null
+          ? []
+          : readyPhasesOf(text, settings.planLanguage, phaseIdsWorkedIn(worked, planHref)),
+      ]
+    }),
+  )
+
 /**
  * The rows the checkout's board file (`checkoutText`) has beyond the board at the base ref, counted as the herd
  * adds them; 0 when the base ref lacks the board, which is then read from the checkout as a whole.