jackherd 1.8.1 → 1.9.0

package/schemas/jackherd.schema.json

@@ -178,6 +178,17 @@
       },
       "additionalProperties": false
     },
+    "preview": {
+      "default": {},
+      "type": "object",
+      "properties": {
+        "publish": {
+          "default": true,
+          "type": "boolean"
+        }
+      },
+      "additionalProperties": false
+    },
     "plans": {
       "default": {},
       "type": "object",
@@ -270,13 +281,13 @@
               "type": "object",
               "properties": {
                 "warnTokens": {
-                  "default": 200000,
+                  "default": 350000,
                   "type": "integer",
                   "exclusiveMinimum": 0,
                   "maximum": 9007199254740991
                 },
                 "alertTokens": {
-                  "default": 300000,
+                  "default": 500000,
                   "type": "integer",
                   "exclusiveMinimum": 0,
                   "maximum": 9007199254740991
@@ -361,6 +372,19 @@
           },
           "additionalProperties": false
         },
+        "parallelTasks": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "maxTokens": {
+              "default": 100000,
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            }
+          },
+          "additionalProperties": false
+        },
         "previews": {
           "type": "object",
           "properties": {

package/src/cli.ts

@@ -24,9 +24,12 @@ export const COMMANDS: CommandTable = {
   [HERD_COMMAND.name]: () => import('./plans/command'),
   init: () => import('./sync/init-command'),
   [HERD_COMMAND.alias]: () => import('./plans/command'),
+  preview: () => import('./preview/command'),
   settled: () => import('./settled/command'),
   sync: () => import('./sync/command'),
+  task: () => import('./task-signals/command'),
   update: () => import('./update/command'),
+  waiting: () => import('./waiting/command'),
   watch: () => import('./watch/command'),
 }
 

package/src/config/schema.ts

@@ -118,6 +118,17 @@ const feedbackSchema = z.strictObject({
   noFindingTemplates: z.array(z.string().min(1)).default([CLEAN_REVIEW_TEXT]),
 })
 
+const DEFAULT_PARALLEL_TASKS_MAX_TOKENS = 100_000
+
+const parallelTasksSchema = z.strictObject({
+  /**
+   * The most the extra agents of a parallel proposal may cost before they do anything: the token baseline of a fresh
+   * agent times the agents to add. Above it the watcher does not propose parallel tasks. The baseline is the context
+   * the first answer of a lane's session carried.
+   */
+  maxTokens: z.number().int().positive().default(DEFAULT_PARALLEL_TASKS_MAX_TOKENS),
+})
+
 const checksSchema = z.strictObject({
   /**
    * Finds a failed test in a line of a red run's log (`gh run view --log-failed`) after its job, step and timestamp
@@ -228,9 +239,9 @@ const hasUniqueNames = (sources: readonly { name: string }[]): boolean =>
 const coordinatorSchema = z
   .strictObject({
     /** Tokens in the coordinator's context from which the watcher reports `coordinator warn`. */
-    warnTokens: tokenCount.default(200_000),
+    warnTokens: tokenCount.default(350_000),
     /** Tokens in the coordinator's context from which the watcher reports `coordinator alert`. */
-    alertTokens: tokenCount.default(300_000),
+    alertTokens: tokenCount.default(500_000),
   })
   .refine(warnBelowAlert, WARN_BELOW_ALERT)
 
@@ -410,6 +421,13 @@ export const jackherdConfigSchema = z.strictObject({
   terminal: z
     .strictObject({ adapter: z.enum(Object.values(TERMINAL_ADAPTER)).default(TERMINAL_ADAPTER.none) })
     .prefault({}),
+  /** How the coordinator shows a draft for review (`orchestrate` § 4). */
+  preview: z
+    .strictObject({
+      /** Publish the draft as a private Artifact when the session has the tool; `false` sends a file card or `jh preview --open` instead. */
+      publish: z.boolean().default(true),
+    })
+    .prefault({}),
   plans: z
     .strictObject({
       /** Minutes between background fetches of the base branch while `jh herd` runs; 0 turns them off. */
@@ -430,6 +448,7 @@ export const jackherdConfigSchema = z.strictObject({
   /**
    * Read by `jh watch`; without `deploy` it reports no deploy runs. `feedback` is on unless set to `false`:
    * it reports new feedback on the lanes' pull requests except from the account the watcher runs as and `ignore`.
+   * `parallelTasks.maxTokens` caps the cost of the extra agents in a proposal of parallel tasks at the heartbeat.
    * `checks` reads the failed tests of a red lane pull request (`failedTestPattern`), also with `feedback` off.
    * Without `previews` it reads no deploy preview; with it, one `preview` per new head commit. Each of `sources` is a
    * command whose JSON output reports `source` for a new or changed entry.
@@ -439,6 +458,7 @@ export const jackherdConfigSchema = z.strictObject({
       deploy: deploySchema.optional(),
       feedback: z.union([z.literal(false), feedbackSchema]).prefault({}),
       checks: checksSchema.prefault({}),
+      parallelTasks: parallelTasksSchema.prefault({}),
       previews: previewsSchema.optional(),
       sources: z.array(sourceSchema).refine(hasUniqueNames, 'source names must be unique').default([]),
     })

package/src/context/fill.ts

@@ -67,3 +67,15 @@ export const contextFill = (lines: readonly string[], windows: ContextWindows):
   const window = windowFor(last.model, highest, windows)
   return { tokens: last.tokens, window, share: Math.min(last.tokens / window, 1), model: last.model }
 }
+
+/**
+ * What a fresh agent carries before it has worked: the input of the first main-chain answer in the lines, which holds
+ * the system prompt, the project instructions and the first request. Null when no line is a usable answer.
+ */
+export const firstAnswerTokens = (lines: readonly string[]): number | null => {
+  for (const line of lines) {
+    const answer = answerOf(line)
+    if (answer) return answer.tokens
+  }
+  return null
+}

package/src/context/session-log.ts

@@ -2,6 +2,7 @@ import { closeSync, existsSync, fstatSync, openSync, readdirSync, readSync, stat
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 import { CLAUDE_DIRECTORY, SESSION_LOGS_DIRECTORY } from '../claude/paths'
+import { isRecord } from '../shared/is-record'
 
 /** How much of the end of a log is read: logs grow to hundreds of megabytes, and the last answers are at the end. */
 export const TAIL_BYTES = 2 * 1024 * 1024
@@ -40,6 +41,20 @@ export const readTailLines = (path: string, bytes: number): string[] => {
   }
 }
 
+/** The complete lines of the first `bytes` of a file: a cut-off last line is dropped, a file read to its end keeps its last one. */
+export const readHeadLines = (path: string, bytes: number): string[] => {
+  const descriptor = openSync(path, 'r')
+  try {
+    const { size } = fstatSync(descriptor)
+    const buffer = Buffer.alloc(Math.min(size, bytes))
+    readSync(descriptor, buffer, 0, buffer.length, 0)
+    const lines = buffer.toString('utf8').split('\n')
+    return size > bytes ? lines.slice(0, -1) : lines
+  } finally {
+    closeSync(descriptor)
+  }
+}
+
 /** The tail of a session's log, read only; null when the session has no log or it cannot be read. */
 export const sessionLog = (
   sessionId: string,
@@ -59,7 +74,7 @@ export type AgentSession = { session: string | null; cwd: string | null }
 const hasAnswer = (lines: readonly string[]): boolean => lines.some((line) => line.includes('"type":"assistant"'))
 
 /** Claude Code names a project directory after the working directory, `/` and `.` turned into `-`. */
-const projectDirectoryOf = (cwd: string): string => cwd.replace(/[/.]/g, '-')
+export const projectDirectoryOf = (cwd: string): string => cwd.replace(/[/.]/g, '-')
 
 const newestLogOf = (cwd: string, projectsDirectory: string): string | null => {
   const directory = join(projectsDirectory, projectDirectoryOf(cwd))
@@ -89,3 +104,30 @@ export const agentLog = (
     return reported
   }
 }
+
+/**
+ * The path of the log `agentLog` would read: the reported session's log when it holds an answer, else the newest log
+ * of the agent's working directory, else the reported one; null when there is none.
+ */
+export const agentLogPath = (
+  { session, cwd }: AgentSession,
+  projectsDirectory: string = defaultProjectsDirectory(),
+): string | null => {
+  const reported = session ? sessionLogPath(session, projectsDirectory) : null
+  try {
+    if (reported && hasAnswer(readTailLines(reported, TAIL_BYTES))) return reported
+    return (cwd ? newestLogOf(cwd, projectsDirectory) : null) ?? reported
+  } catch {
+    return reported
+  }
+}
+
+/** One line of a session log as an object; null for a line that is no JSON or not an object. */
+export const parseLogEntry = (line: string): Record<string, unknown> | null => {
+  try {
+    const entry: unknown = JSON.parse(line)
+    return isRecord(entry) ? entry : null
+  } catch {
+    return null
+  }
+}

package/src/plan-format/clock.ts

@@ -0,0 +1,4 @@
+export const MS_PER_MINUTE = 60_000
+
+/** A day, month, hour or minute with a leading zero: `7` → `07`. */
+export const twoDigits = (value: number): string => String(value).padStart(2, '0')

package/src/plan-format/dependencies.ts

@@ -1,5 +1,5 @@
 import { PLAN_VOCABULARY, type PlanLanguage } from '../vocabulary'
-import { PHASE_ID_PREFIX, phaseLabels } from './lanes'
+import { PHASE_ID_PREFIX, phaseLabels, spannedPhaseIds } from './lanes'
 import { escapeRegExp, firstTableWithHeader, subsectionLines } from './markdown'
 import { type PhaseHeading, parsePlanPhases, phaseHeadings } from './phases'
 import { isPhaseFinished } from './progress'
@@ -40,7 +40,6 @@ const VERSION = /^v?\d+(?:[.\-+][\w.-]*)?$/i
 const PACKAGE_SCOPE = /^@[^/]+\//
 /** The files a release of the package in their directory changes: the changelog and the version in the manifest. */
 const RELEASE_FILE = /(?:^|\/)(?:CHANGELOG\.md|package\.json)$/
-const MAX_RANGE = 50
 
 const phaseIdOf = (cell: string): string | null => PHASE_ID.exec(cell)?.[1]?.toLowerCase() ?? null
 
@@ -63,9 +62,7 @@ const splitOutsideParentheses = (cell: string, separator: string): string[] => {
 const rangeOf = (entry: string): string[] | null => {
   const match = PHASE_RANGE.exec(entry)
   if (!match) return null
-  const [first, last] = [Number(match[1]), Number(match[2])]
-  if (first > last || last - first >= MAX_RANGE) return []
-  return Array.from({ length: last - first + 1 }, (_, offset) => String(first + offset))
+  return spannedPhaseIds(Number(match[1]), Number(match[2]))
 }
 
 const dependsOf = (cell: string, language: PlanLanguage): Pick<PhaseDependency, 'after' | 'external'> => {

package/src/plan-format/lanes.ts

@@ -32,6 +32,15 @@ export const PHASE_ID_PREFIX = 'P'
 /** A phase as plans and reports name it: `P4`. */
 export const phaseLabel = (id: string): string => `${PHASE_ID_PREFIX}${id}`
 
+/** The widest range a cell may span; a wider one is a typo, not a plan. */
+const MAX_RANGE = 50
+
+/** The ids from `first` to `last`, both included; empty when the range runs backwards or spans `MAX_RANGE` or more. */
+export const spannedPhaseIds = (first: number, last: number): string[] =>
+  first > last || last - first >= MAX_RANGE
+    ? []
+    : Array.from({ length: last - first + 1 }, (_, offset) => String(first + offset))
+
 /** Phases as plans and reports name them, joined by `separator`: `P3 P4`, `P19 ∥ P20`. */
 export const phaseLabels = (ids: readonly string[], separator: string): string => ids.map(phaseLabel).join(separator)
 
@@ -39,22 +48,32 @@ const PHASES_COLUMN = 3
 const CLAUSE_SEPARATOR = /([;,]|\.(?=\s))\s*/
 const ENTRY_END = new Set([';', '.'])
 
-type PhaseIdPatterns = { leading: RegExp; afterConnector: RegExp; connector: RegExp }
+type PhaseIdPatterns = { leading: RegExp; rangeEnd: RegExp; afterConnector: RegExp; connector: RegExp }
 
 const phaseIdPatterns = (language: PlanLanguage): PhaseIdPatterns => {
   const connectors = PLAN_VOCABULARY[language].phaseConnectors.join('|')
   const id = `(?:\\*\\*)?${PHASE_ID_PREFIX}(\\d+[a-z]?)\\b`
   return {
     leading: new RegExp(`^\\s*(?:(?:${connectors})\\s+)*${id}`),
+    rangeEnd: new RegExp(`^\\s*[–-]\\s*(?:\\*\\*)?${PHASE_ID_PREFIX}(\\d+)\\b`),
     afterConnector: new RegExp(`^\\s*(?:${connectors})\\s`),
     connector: new RegExp(`\\b(?:${connectors})\\s+${id}`, 'g'),
   }
 }
 
+/** The ids an entry starting with `leading` names: the one id, or every id of a range `P17–P25` it opens. */
+const leadingIds = (clause: string, leading: RegExpMatchArray, patterns: PhaseIdPatterns): string[] => {
+  const first = leading[1]
+  const end = clause.slice(leading[0].length).match(patterns.rangeEnd)
+  if (!end || !/^\d+$/.test(first)) return [first]
+  const spanned = spannedPhaseIds(Number(first), Number(end[1]))
+  return spanned.length > 0 ? spanned : [first]
+}
+
 /**
  * The phase ids of a phases cell. An id counts where an entry starts: at the start of the cell or of a
  * sentence, after `;`, after a connector word (`P1 Index und P2 Suche`), or after `,` while a list that began
- * with an id is running (`P1 (#<number>), P2 (#<number>)`). A `P6` inside a sentence (`geht in P6 auf`, `abgeräumt,
+ * with an id is running (`P1 (#<number>), P2 (#<number>)`); an entry `P17–P25` names every phase it spans. A `P6` inside a sentence (`geht in P6 auf`, `abgeräumt,
  * P6 startet neu`) is prose.
  */
 const phaseIdsOf = (cell: string, patterns: PhaseIdPatterns): string[] => {
@@ -69,7 +88,7 @@ const phaseIdsOf = (cell: string, patterns: PhaseIdPatterns): string[] => {
     const leading = clause.match(patterns.leading)
     const startsEntry: boolean = entryStart || listRunning || patterns.afterConnector.test(clause)
     const counts: boolean = leading !== null && startsEntry
-    if (leading && counts) ids.push(leading[1])
+    if (leading && counts) ids.push(...leadingIds(clause, leading, patterns))
     ids.push(...[...clause.matchAll(patterns.connector)].map((match) => match[1]))
     listRunning ||= counts
   }
@@ -111,7 +130,8 @@ export const withoutRepeats = (lane: SprintLane, step: PlanStep): PlanStep => {
 /**
  * The lanes of the sprint document's lanes table (`## Spuren` in `de`) in table order. A row whose
  * first cell names a lane in backticks belongs to that lane; a `↳` row without a name continues
- * the lane above it.
+ * the lane above it. A cleaned-up lane stays closed through its `↳` rows, but a later row that names it again
+ * without the mark starts the lane anew: the closed rows are history and drop out.
  */
 export const parseSprintLanes = (markdown: string, language: PlanLanguage): SprintLane[] => {
   const lanes = new Map<string, SprintLane>()
@@ -123,7 +143,12 @@ export const parseSprintLanes = (markdown: string, language: PlanLanguage): Spri
     if (!name) continue
     const port = Number.parseInt(cells[1] ?? '', 10)
     const lane = lanes.get(name) ?? { name, port: Number.isNaN(port) ? null : port, steps: [], closed: false }
-    lane.closed ||= (cells[0] ?? '').includes(laneClosed)
+    const marked = (cells[0] ?? '').includes(laneClosed)
+    if (lane.closed && !marked && !(cells[0] ?? '').startsWith(CONTINUATION)) {
+      lane.closed = false
+      lane.steps = []
+    }
+    lane.closed ||= marked
     lane.steps.push(withoutRepeats(lane, toStep(cells, phaseId)))
     lanes.set(name, lane)
     previous = name

package/src/plan-format/terminal-text.ts

@@ -26,3 +26,7 @@ const UNSAFE_TERMINAL_TEXT = new RegExp(
  * on the terminal. Apply it where such text enters, before any styling is added.
  */
 export const terminalSafe = (text: string): string => text.replace(UNSAFE_TERMINAL_TEXT, '')
+
+/** The text cut to `max` characters with an ellipsis as the last one; text that fits stays as it is. */
+export const ellipsize = (text: string, max: number): string =>
+  text.length > max ? `${text.slice(0, max - 1)}…` : text

package/src/plan-format/waiting.ts

@@ -0,0 +1,48 @@
+import { type PlanLanguage, WAITING_VOCABULARY } from '../vocabulary'
+import { firstTableWithHeader, sectionLines } from './markdown'
+import { terminalSafe } from './terminal-text'
+
+/** One row of the board's section of what waits on the user: when it began (as written), what it is, whether it is open. */
+export type WaitingItem = {
+  since: string
+  item: string
+  open: boolean
+  /** A `file:` address the item links to, for a sent file; absent for a row of the board. */
+  url?: string
+  /** `file` for a file or an Artifact that was sent; absent for a question of the board. */
+  kind?: 'file'
+  /** The id of the record that closes it (`jh waiting close`); not shown. */
+  id?: string
+}
+
+const oneLine = (text: string): string => terminalSafe(text).replace(/\s+/g, ' ').trim()
+
+/** An empty status counts as open: a row nobody closed is not dropped in silence. */
+const isOpen = (status: string, language: PlanLanguage): boolean => {
+  const lower = status.toLowerCase()
+  return lower === '' || WAITING_VOCABULARY[language].open.some((word) => lower.startsWith(word))
+}
+
+/**
+ * The rows of the board's waiting section in `language` (`## Wartet auf dich`, `## Waiting for you`), its columns
+ * found by their header names in any order; the origin column is not read. A table without the since, item or status
+ * column, a section without a table and a row without an item give nothing.
+ */
+export const readWaitingItems = (board: string, language: PlanLanguage): WaitingItem[] => {
+  const { heading, columns, statusAlso } = WAITING_VOCABULARY[language]
+  const { header, rows } = firstTableWithHeader(sectionLines(board, heading))
+  const statusName = [columns.status, ...statusAlso].find((name) => header.includes(name)) ?? columns.status
+  const positions = [columns.since, columns.item, statusName].map((name) => header.indexOf(name))
+  if (positions.includes(-1)) return []
+  const [since, item, status] = positions
+  return rows.flatMap((cells) => {
+    const text = oneLine(cells[item] ?? '')
+    return text === ''
+      ? []
+      : [{ since: oneLine(cells[since] ?? ''), item: text, open: isOpen(cells[status] ?? '', language) }]
+  })
+}
+
+/** The open items, in the order of the board. */
+export const openWaitingItems = (board: string, language: PlanLanguage): WaitingItem[] =>
+  readWaitingItems(board, language).filter(({ open }) => open)

package/src/plans/active-tasks.ts

@@ -0,0 +1,60 @@
+import { sep } from 'node:path'
+import { terminalSafe } from '../plan-format/terminal-text'
+import { matchSignals, type OpenPlanTask } from '../task-signals/matcher'
+import type { TaskSignal } from '../task-signals/types'
+import type { TaskPhase } from './current-task'
+
+/**
+ * A task an agent is working on: its index among the phase's checkboxes, who works on it (null while only one agent
+ * is active in the lane), whether the herd only guesses it from words, and when the agent began it (null for a guess).
+ */
+export type ActiveTask = { index: number; agent: string | null; guessed: boolean; startedAt: number | null }
+
+/** A task an agent reports that no open task of the plan names. */
+export type UnplannedTask = { text: string; agent: string | null }
+
+export type Assignment = { byPhase: ReadonlyMap<string, ActiveTask[]>; unplanned: UnplannedTask[] }
+
+const openTasksOf = (phases: readonly TaskPhase[]): OpenPlanTask[] =>
+  phases.flatMap(({ id, items }) =>
+    items.flatMap((item, taskIndex) => (item.done ? [] : [{ phaseId: id, taskIndex, text: item.text }])),
+  )
+
+/**
+ * Lays the reported `signals` over the plan's open tasks: each task an agent named is active, grouped by phase in the
+ * order of the signals, two agents on one task share it; a signal that names no open task is unplanned. Agent text is
+ * made terminal safe here, and the agent is named only when more than one agent reports.
+ */
+export const assignSignals = (phases: readonly TaskPhase[], signals: readonly TaskSignal[]): Assignment => {
+  const named = new Set(signals.map(({ agent }) => terminalSafe(agent))).size > 1
+  const nameOf = (agent: string): string | null => (named ? terminalSafe(agent) : null)
+  const byPhase = new Map<string, ActiveTask[]>()
+  const unplanned: UnplannedTask[] = []
+  for (const { signal, task } of matchSignals(openTasksOf(phases), signals)) {
+    if (task === null) {
+      unplanned.push({ text: terminalSafe(signal.text), agent: nameOf(signal.agent) })
+      continue
+    }
+    const tasks = byPhase.get(task.phaseId) ?? []
+    const shared = tasks.find(({ index }) => index === task.taskIndex)
+    const agent = nameOf(signal.agent)
+    if (shared) shared.agent = shared.agent && agent ? `${shared.agent}, ${agent}` : shared.agent
+    else tasks.push({ index: task.taskIndex, agent, guessed: false, startedAt: signal.startedAt })
+    byPhase.set(task.phaseId, tasks)
+  }
+  return { byPhase, unplanned }
+}
+
+/**
+ * The signals still believed: a `jh task` record counts only while it is younger than the lane's last tick, since a
+ * ticked box is the better witness that the agent moved on; Claude's own task list closes itself. Without a tick, all stay.
+ */
+export const freshSignals = (signals: readonly TaskSignal[], lastTickAt: number | null): TaskSignal[] =>
+  signals.filter(({ source, startedAt }) => source !== 'jh' || lastTickAt === null || startedAt >= lastTickAt)
+
+/** The lane a directory belongs to: the first directory below `worktrees` it lies in; null anywhere else. */
+export const laneOfDirectory = (directory: string, worktrees: string): string | null => {
+  const prefix = worktrees.endsWith(sep) ? worktrees : `${worktrees}${sep}`
+  if (!directory.startsWith(prefix)) return null
+  return directory.slice(prefix.length).split(sep)[0] || null
+}

package/src/plans/current-phase.ts

@@ -6,7 +6,7 @@ export type PhaseRef = { planHref: string; phaseId: string }
 /** Per plan link and phase id, the state of its checkboxes as `1` (ticked) and `0` (open) in plan order. */
 export type TickSnapshot = Record<string, Record<string, string>>
 
-/** When a phase's ticks or task lines last moved, in milliseconds, by `activityKey`. */
+/** When a phase was last ticked or unticked, in milliseconds, by `activityKey`. */
 export type ActivityTimes = Readonly<Record<string, number>>
 
 /**
@@ -54,20 +54,30 @@ export const movedPhases = (previous: TickSnapshot, next: TickSnapshot): PhaseRe
     }),
   )
 
-/** The phases `next` has in a plan `previous` read already but without them: task lines a lane wrote into a new phase. */
-const addedPhases = (previous: TickSnapshot, next: TickSnapshot): PhaseRef[] =>
+const tickCount = (ticks: string): number => [...ticks].filter((state) => state === '1').length
+
+/**
+ * The phases whose number of ticks changed between two reads of a plan `previous` read already, a phase new in `next`
+ * counted from none: a tick is activity, task lines written into a phase are not, so phases a lane only wrote down
+ * never run (17:10). A phase remembered in the format before D67 has no state to move from.
+ */
+const tickedPhases = (previous: TickSnapshot, next: TickSnapshot): PhaseRef[] =>
   Object.entries(next).flatMap(([planHref, phases]) => {
     const before = previous[planHref]
     if (before === undefined) return []
-    return Object.keys(phases).flatMap((phaseId) => (phaseId in before ? [] : [{ planHref, phaseId }]))
+    return Object.entries(phases).flatMap(([phaseId, ticks]) => {
+      const old = before[phaseId]
+      if (old !== undefined && !old.startsWith(TASK_TICKS)) return []
+      return tickCount(old ?? '') === tickCount(ticks) ? [] : [{ planHref, phaseId }]
+    })
   })
 
 /** When each plan file was last written, in milliseconds, by plan link; a plan without an entry is bounded by the clock. */
 export type PlanModified = Readonly<Record<string, number>>
 
 /**
- * When each phase last moved, after a read at `now` whose ticks are `ticks`: a phase whose ticks or task lines changed
- * since `previous`, or that is new in a plan `previous` read already, takes the time its plan file was last written
+ * When each phase was last ticked, after a read at `now` whose ticks are `ticks`: a phase whose number of ticks changed
+ * since `previous` (`tickedPhases`), a new one in a plan `previous` read already included, takes the time its plan file was last written
  * (`modified`), bounded by `now`, so a change first seen long after it was made is not taken for a fresh one; the
  * others keep their time. The first read knows no movement, so without a remembered read no phase has a time.
  */
@@ -78,7 +88,7 @@ export const nextActivity = (
   modified: PlanModified = {},
 ): ActivityTimes => {
   if (!previous) return {}
-  const changed = [...movedPhases(previous.ticks, ticks), ...addedPhases(previous.ticks, ticks)]
+  const changed = tickedPhases(previous.ticks, ticks)
   return {
     ...previous.activity,
     ...Object.fromEntries(

package/src/plans/current-task.ts

@@ -1,10 +1,12 @@
+import { parseLogEntry } from '../context/session-log'
 import type { PlanPhase } from '../plan-format'
+import { isRecord } from '../shared/is-record'
 
 /**
  * A hint that a phase's task is being worked on: `taskIndex` is the task's index in the phase's checkboxes, `at` when
- * it was seen, in milliseconds. No source writes one yet, so the heuristic of `currentTasks` decides alone.
+ * it was seen, in milliseconds. `taskSignalsOf` derives them from what the lane's agents did lately.
  */
-export type TaskSignal = { phaseId: string; taskIndex: number; at: number }
+export type TaskActivity = { phaseId: string; taskIndex: number; at: number }
 
 /** A phase as `currentTasks` reads it: its id and checkboxes. */
 export type TaskPhase = Pick<PlanPhase, 'id' | 'items'>
@@ -14,14 +16,17 @@ const isOpenTask = (phase: TaskPhase, index: number): boolean => phase.items[ind
 /** The task the newest signal younger than `staleAfterMs` points at, when it is still open; null otherwise. */
 const signalledTask = (
   phase: TaskPhase,
-  signals: readonly TaskSignal[],
+  signals: readonly TaskActivity[],
   now: number,
   staleAfterMs: number,
 ): number | null => {
   const fresh = signals
     .filter((signal) => signal.phaseId === phase.id && now - signal.at < staleAfterMs)
     .filter((signal) => isOpenTask(phase, signal.taskIndex))
-  const newest = fresh.reduce<TaskSignal | null>((last, signal) => (last && last.at >= signal.at ? last : signal), null)
+  const newest = fresh.reduce<TaskActivity | null>(
+    (last, signal) => (last && last.at >= signal.at ? last : signal),
+    null,
+  )
   return newest?.taskIndex ?? null
 }
 
@@ -38,7 +43,7 @@ const firstOpenTask = ({ items }: TaskPhase): number => {
  */
 export const currentTasks = (
   plan: readonly TaskPhase[],
-  signals: readonly TaskSignal[],
+  signals: readonly TaskActivity[],
   now: number,
   staleAfterMs: number,
 ): ReadonlyMap<string, number> =>
@@ -49,3 +54,56 @@ export const currentTasks = (
       return [[phase.id, signalledTask(phase, signals, now, staleAfterMs) ?? first] as const]
     }),
   )
+
+const WORD = /[a-zäöüß][a-zäöüß0-9-]{5,}/g
+/** The share of a task's distinctive words the agent used, from which on it counts as working on that task. */
+const SIGNAL_SHARE = 0.4
+const SIGNAL_MIN_WORDS = 3
+/** Only the start of a task's text is read: the rest is reasons and origin. */
+const TASK_TEXT_LENGTH = 200
+
+const wordsOf = (text: string): Set<string> => new Set(text.toLowerCase().match(WORD) ?? [])
+
+/**
+ * The signal each phase gets from what an agent of the lane did lately (`activity`, see `activityTextOf`): the open
+ * task of which the agent used at least `SIGNAL_SHARE` of the distinctive words (six letters or more, from the first
+ * 200 characters) and at least three, and clearly the most of all open tasks of the phase. Measured against the logs of
+ * the lane's agents: the prompt alone names several tasks, the words of the last entries single one out; the first open
+ * task stays the fallback when no task leads.
+ */
+export const taskSignalsOf = (plan: readonly TaskPhase[], activity: string, at: number): TaskActivity[] => {
+  const used = wordsOf(activity)
+  if (used.size === 0) return []
+  return plan.flatMap((phase) => {
+    const scored = phase.items.flatMap((item, taskIndex) => {
+      if (item.done) return []
+      const words = [...wordsOf(item.text.slice(0, TASK_TEXT_LENGTH))]
+      const hits = words.filter((word) => used.has(word)).length
+      return words.length > 0 && hits >= SIGNAL_MIN_WORDS && hits / words.length >= SIGNAL_SHARE
+        ? [{ taskIndex, hits }]
+        : []
+    })
+    const [best, second] = scored.sort((left, right) => right.hits - left.hits)
+    return best && best.hits > (second?.hits ?? 0) ? [{ phaseId: phase.id, taskIndex: best.taskIndex, at }] : []
+  })
+}
+
+const contentTexts = (content: unknown): string[] => {
+  if (typeof content === 'string') return [content]
+  if (!Array.isArray(content)) return []
+  return content.flatMap((block) => {
+    if (typeof block !== 'object' || block === null) return []
+    const { text, input } = block as { text?: unknown; input?: unknown }
+    return [typeof text === 'string' ? text : '', input === undefined ? '' : JSON.stringify(input)]
+  })
+}
+
+/** The text of an agent's last `entries` log entries (messages and tool inputs), for `taskSignalsOf`; lines that are no JSON are skipped. */
+export const activityTextOf = (lines: readonly string[], entries: number): string =>
+  lines
+    .slice(-entries)
+    .flatMap((line) => {
+      const message = parseLogEntry(line)?.message
+      return isRecord(message) ? contentTexts(message.content) : []
+    })
+    .join(' ')

package/src/plans/lane-standing.ts

@@ -45,15 +45,20 @@ const hasOpenWork = (progress: StandingInput['progress']): boolean => {
 }
 
 /**
- * Where a lane stands on the board. The cleaned-up mark goes first: it closes a lane, unless an agent, a worktree
- * or a pull request is still there, which keeps it listed. Then an agent, an open pull request or
- * uncommitted changes in its worktree make a lane active (a small fix has no agent in herdr) and a worktree alone lists it. Without a worktree a lane waits while it has open work, else it is closed.
+ * Where a lane stands on the board. An agent, an open pull request or uncommitted changes in its worktree make a
+ * lane active (a small fix has no agent in herdr). The cleaned-up mark goes first, but uncommitted changes in the
+ * worktree beat it: work is going on, whatever the board says. Otherwise the mark closes a lane, unless an agent, a
+ * worktree or a pull request is still there, which keeps it listed. A worktree alone lists a lane. Without a
+ * worktree a lane waits while it has open work, else it is closed.
  */
 export const laneStanding = (input: StandingInput): LaneStanding => {
   const { progress, status, pullRequests } = input
   const working = status.agent !== null || pullRequests.length > 0
   const editedInWorktree = status.branch !== null && status.dirty > 0
-  if (progress.lane.closed) return working || status.branch !== null ? LANE_STANDING.noAgent : LANE_STANDING.closed
+  if (progress.lane.closed) {
+    if (editedInWorktree) return LANE_STANDING.active
+    return working || status.branch !== null ? LANE_STANDING.noAgent : LANE_STANDING.closed
+  }
   if (working || editedInWorktree) return LANE_STANDING.active
   if (status.branch !== null) return LANE_STANDING.noAgent
   return hasOpenWork(progress) ? LANE_STANDING.waiting : LANE_STANDING.closed