jackherd 1.14.0 → 1.15.0

package/src/watch/lane-report.ts

@@ -1,9 +1,22 @@
 import { CONTEXT_LEVEL, type ContextLevel, contextLabel } from '../context'
 import { closeDryRunOf } from '../lane/close-command-line'
-import { currentPhase, isTickedUnmerged, type LaneProgress, phasesText } from '../plan-format'
+import {
+  currentPhase,
+  isPhaseFinished,
+  isPhaseOpen,
+  isTickedUnmerged,
+  type LaneProgress,
+  parseDependencyTable,
+  parsePlanPhases,
+  phaseLabel,
+  phaseLabels,
+  phasesText,
+} from '../plan-format'
 import { terminalSafe } from '../plan-format/terminal-text'
 import { CHECK_NAME_LENGTH, type ChecksState } from '../plans/pull-requests'
 import { shownWithMore } from '../plans/shown-with-more'
+import { AGENT_STATUS } from '../terminal/types'
+import type { PlanLanguage } from '../vocabulary'
 import type { AppointmentEvent } from './appointments'
 import type { ApprovalEvent } from './approvals'
 import type { CoordinatorRead } from './coordinator-fill'
@@ -12,7 +25,7 @@ import type { LaneFillEvent } from './lane-fill'
 import type { LaneModelEvent } from './lane-model'
 import type { LaneParallelEvent } from './lane-parallel'
 import { laneStalledLine } from './lane-stalled'
-import { AGENT_STATUS, type LaneSnapshot, NO_AGENT } from './lane-watch'
+import { type LaneSnapshot, NO_AGENT } from './lane-watch'
 import { PLAN_MISSING_EVENT, type PlanMissingEvent, planMissingLine } from './plan-missing'
 import { PULL_REQUEST_STATE, type WatchedPullRequest } from './pull-requests'
 import { SOURCE_FIELD } from './source-fields'
@@ -370,6 +383,48 @@ export const blockedDutyLines = (stopped: readonly string[], current: LaneSnapsh
     .filter((lane) => current[lane]?.status === AGENT_STATUS.blocked)
     .map((lane) => `${terminalSafe(lane)} ${AGENT_STATUS.blocked}: ${texts.blockedDuty}`)
 
+/** An open phase whose dependencies are all ticked off, with the phases it waited for. */
+export type ReadyPhase = { id: string; after: string[] }
+
+/**
+ * The phases of a plan that can start now, in table order: open, not worked on (`worked`, the ids of the phases the
+ * lanes work on), every phase of the `Depends on` cell finished and no external gate in it. Empty for a plan without
+ * a dependency table or a row without a phase in the plan.
+ */
+export const readyPhasesOf = (markdown: string, language: PlanLanguage, worked: ReadonlySet<string>): ReadyPhase[] => {
+  const table = parseDependencyTable(markdown, language) ?? []
+  const phases = parsePlanPhases(markdown, language)
+  const finished = new Set(phases.filter(isPhaseFinished).map(({ id }) => id))
+  const open = new Set(phases.filter(isPhaseOpen).map(({ id }) => id))
+  return table
+    .filter(
+      ({ id, after, external }) =>
+        open.has(id) && !worked.has(id) && external.length === 0 && after.every((each) => finished.has(each)),
+    )
+    .map(({ id, after }) => ({ id, after }))
+}
+
+const readyPhaseText = ({ id, after }: ReadyPhase): string =>
+  `${phaseLabel(id)}${after.length > 0 ? ` (after ${phaseLabels(after, ', ')})` : ''}`
+
+/**
+ * What a resting lane (`done` or `idle`) with ready phases asks of the coordinator (`orchestrate` § 2): one line per such
+ * lane, naming every ready phase, to start it now; a pull request waiting for approval holds only the commit.
+ */
+export const readyPhaseDutyLines = (
+  stopped: readonly string[],
+  current: LaneSnapshot,
+  ready: Readonly<Record<string, readonly ReadyPhase[]>>,
+  texts: WatchTexts,
+): string[] =>
+  stopped.flatMap((lane) => {
+    const phases = ready[lane] ?? []
+    if (phases.length === 0 || !RESTING_STATUSES.has(current[lane]?.status ?? '')) return []
+    return [
+      `${terminalSafe(lane)} ready: ${phases.map(readyPhaseText).join(', ')}: ${texts.readyPhaseDuty(phases.length)}`,
+    ]
+  })
+
 const takeOverNote = ({ replaced, stillRunning }: TakeOver): string => {
   if (stillRunning !== null) return ` (watcher ${stillRunning} did not stop)`
   return replaced === null ? '' : ` (replaced watcher ${replaced})`

package/src/watch/lane-watch.ts

@@ -1,7 +1,6 @@
-export type HerdrAgent = { name?: string; pane_id: string; agent_status: string; state_change_seq?: number }
+import { AGENT_STATUS } from '../terminal/types'
 
-/** The herdr agent states; herdr's JSON delivers them as plain strings. */
-export const AGENT_STATUS = { working: 'working', blocked: 'blocked', done: 'done', idle: 'idle' } as const
+export type HerdrAgent = { name?: string; pane_id: string; agent_status: string; state_change_seq?: number }
 
 /** The state a report gives a lane whose agent left the herdr listing. */
 export const LANE_GONE = 'no longer listed'
@@ -9,8 +8,6 @@ export const LANE_GONE = 'no longer listed'
 /** The state a report gives a lane that has no agent in herdr. */
 export const NO_AGENT = 'no agent'
 
-export type AgentStatus = (typeof AGENT_STATUS)[keyof typeof AGENT_STATUS]
-
 export type LaneState = { status: string; seq: number | null }
 
 export type LaneSnapshot = Record<string, LaneState>
@@ -20,9 +17,6 @@ export type SeenSeqs = Record<string, number | null>
 
 const STOP_STATUSES = new Set<string>([AGENT_STATUS.blocked, AGENT_STATUS.done, AGENT_STATUS.idle])
 
-export const isAgentStatus = (value: string): value is AgentStatus =>
-  (Object.values(AGENT_STATUS) as string[]).includes(value)
-
 /** The state of each named lane in a `herdr agent list` answer; unnamed and other agents are left out. */
 export const toSnapshot = (agents: readonly HerdrAgent[], lanes: readonly string[]): LaneSnapshot =>
   Object.fromEntries(

package/src/watch/task-parallel-touched.ts

@@ -1,13 +1,20 @@
 import { isAbsolute, relative } from 'node:path'
+import { CLAUDE_TOOL, CONTENT_BLOCK_TYPE } from '../context/log-vocabulary'
 import { parseLogEntry } from '../context/session-log'
 import { isRecord } from '../shared/is-record'
 
-const WRITING_TOOLS: ReadonlySet<string> = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit'])
+const WRITING_TOOLS: ReadonlySet<string> = new Set([
+  CLAUDE_TOOL.edit,
+  CLAUDE_TOOL.write,
+  CLAUDE_TOOL.multiEdit,
+  CLAUDE_TOOL.notebookEdit,
+])
 
 const writtenPathsOf = (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' || !WRITING_TOOLS.has(String(block.name))) return []
+    if (!isRecord(block) || block.type !== CONTENT_BLOCK_TYPE.toolUse || !WRITING_TOOLS.has(String(block.name)))
+      return []
     const input = isRecord(block.input) ? block.input : {}
     const path = input.file_path ?? input.notebook_path
     return typeof path === 'string' ? [path] : []

package/src/watch/texts.ts

@@ -32,6 +32,8 @@ export type WatchTexts = {
   planMissingDuty: string
   /** What a lane's call waiting for approval asks of the coordinator, with the mark (request id and call hash) the question must carry. */
   approvalDuty: (id: string, hash: string) => string
+  /** What a resting lane with ready phases asks of the coordinator, with how many phases are ready. */
+  readyPhaseDuty: (count: number) => string
   /** The standing duty while the main checkout is behind its base branch on the remote (`origin/main`), with the count of commits. */
   mainCheckoutBehind: (remoteBase: string, count: number) => string
   /** The standing duty while the main checkout has another branch than the base checked out (null for a detached head). */
@@ -76,6 +78,8 @@ export const watchTexts = (dialogLanguage: PlanLanguage): WatchTexts => ({
     "the herd shows the base ref's plan, not this one: run § 2 step 0 for it, copying from the lane's worktree",
   laneModelDuty:
     'switch it while idle: /exit, then claude --resume <session> --model <id> in the same pane (§ 2 step 6)',
+  readyPhaseDuty: (count) =>
+    `start ${count === 1 ? 'it' : 'them'} now (§ 2); a waiting PR approval holds only the commit`,
   mainCheckoutBehind: (remoteBase, count) =>
     `main checkout behind ${remoteBase} by ${count} (git merge --ff-only ${remoteBase})`,
   mainCheckoutOffBase: (branch, baseBranch) => `main checkout on ${branch ?? 'a detached head'}, not ${baseBranch}`,