jackherd 1.8.0 → 1.9.0

package/kit/workflow/skills/orchestrate/SKILL.md

@@ -19,6 +19,7 @@ commit, push or merge without the user's approval.
 **A small fix runs without a lane:** one pull request, no plan, no migration, no write against a shared
 environment. An `implement` subagent builds it; you take its git steps on a short branch (§ 0), under the
 same approval (§ 5), and record it in one line of the board's `{{kit.heading.history}}` instead of a lane row and a plan.
+A small fix that builds a phase of a plan gets a row in the board's `{{kit.heading.lanes}}` table (name, plan link, phase), so the herd shows it; without a phase it stays a history line.
 
 > Lanes run `/implement`, not this skill. Never paste these rules into a lane prompt.
 
@@ -88,6 +89,9 @@ Always contains:
 - what the lane must not do: push a database migration and any write against a shared environment
   (stage, production) without the user's approval, `git reset` or `git stash` on shared refs
 - "ask before every commit (`/pre-commit`); no push, PR or merge without approval"
+- "before you start a task, mark it in progress in your own task list; without one, run `jh task start
+  "<task text>"`, and `jh task done` when it is finished": the herd shows the task you work on from that
+  signal
 - "a new phase starts with its skeleton in the plan (heading, origin, tasks, review gate) before any
   research, so the herd never shows it as not in the plan"
 - "the report at the end of each step goes to `.claude/handover/<lane>-report.md` in the worktree,
@@ -410,13 +414,14 @@ On wake-up:
 | `deploy …` | Result and target as the run states them, to the user; a target `unknown (…)` is reported as unknown, never guessed. A failed run goes to the user as an `AskUserQuestion`: read the logs now or later |
 | `due <when> · <action>` | An open appointment fell due (**An agreed time**, below); the action is cut to 160 characters, the board row holds it whole. Carry it out as agreed, under the approvals it needs (§ 5), then write the outcome into its status cell in the same turn |
 | `appointment unreadable <when> · <action>` | An open appointment row whose time cannot be read, or a table without a column the watcher needs (`missing columns: …`). Correct the row or the header in the board; until then the appointment never falls due |
-| `heartbeat` | One line of status to the user, also when nothing changed |
+| `heartbeat` | One line of status to the user, also when nothing changed; a resting lane carries `waits on: <question>, <n> open questions` from its report, and `for you (<n>): …` names what still waits on the user (**Anything that waits on the user's answer**, below): remind the user of those items in that line |
 | `gh unavailable` | Tell the user once; herdr watching continues |
 | `lane <name> warn` | One line to the user: the lane's fill and that it hands over at a phase boundary if it rises further; no step in the lane |
 | `lane <name> alert` | § 8: send the lane once the request for its hand-over at the end of its current phase |
 | `approval <name> <id> <tool> · <call>` | A call of the lane waits for the user's approval (§ 4, Approvals); the duty line names the question's mark and labels |
 | `model <name> <id> · board <column>` | The lane's last answer came from a model its board row's model column does not name (every model the column names fits). Switch it while it is idle (§ 2 step 6). A column that is wrong goes to the user instead. The watcher reports a deviation once and again only when the model changes |
 | `parallel <name> P<a> ∥ P<b>` | The lane's plan has ready phases whose `{{kit.heading.writes}}` sets do not overlap and that share no `{{kit.heading.serialMarker}}`, read from the plan's `{{kit.heading.dependencies}}` table and its ticks. Propose them to the user in one line, as parallel lanes (§ 2) or as parallel subagents in one lane (`/implement` Step 0b); nothing starts on the event alone. Before proposing, check what the table cannot see: two phases that collide in content stay your judgement. The watcher reports a set once and again only when the set changes |
+| `parallel tasks <name>: "<a>" ∥ "<b>" · ~<n>k tokens for <m> extra agents` | Open tasks that name paths overlapping neither each other nor what the running agents wrote lately or report (your own subagents in the lane's worktree count as running), at a cost under `watch.parallelTasks.maxTokens`; one free task beside a running agent counts. Once per changed situation, at a heartbeat. Nothing starts on the line. Put it to the user at once, never into an open dialog (right after it), the user's note read first: at most three plain lines (which tasks, why they do not collide, the cost: model and token baseline of a new agent, and what they wait for otherwise; no invented time saving), then one `AskUserQuestion` of at most 15 words, "start in parallel" (recommended only under the threshold; `Parallel starten` / `Nacheinander lassen` for a German user) or "keep in sequence". Until the answer it is a `?` row in the user's answers section (**Anything that waits on the user's answer**). No second proposal for the same situation after "keep in sequence". Two tasks that collide in content stay your judgement |
 | `coordinator warn` / `coordinator alert` | § 8, for yourself |
 | `lane added: <name>` | Nothing: the lane is watched. Check that it has its row (§ 2 step 5); a name `<lane>-<purpose>` without a worktree is a helper agent of that lane (§ 1) and needs no row. One the lane did not announce goes to the user |
 | `lane removed: <name>` | Nothing after you closed it (§ 7). Otherwise its agent exited or its worktree is gone: read why, then tell the user |
@@ -453,6 +458,20 @@ watcher reports an open row once when it falls due (`due`, below); an empty stat
 and a reworded or moved row is a new appointment and reports again. Close a reported row through its
 status cell.
 
+**Anything that waits on the user's answer** (a preview or a file sent to them, a question put to them, a
+report handed over for acceptance) goes into the board at once, in the section `## Wartet auf dich` (German
+plans) or `## Waiting for you` (English), one row `Since | Item | Origin | Status` (`Seit | Punkt | Herkunft |
+Stand`) with the time as in **An agreed time**. The section survives a hand-over, which a message in this chat
+does not. Enter the row in the same turn you send the thing, not when you notice it was missed. The herd shows
+every open row on top as `for you`, and the watcher repeats them in each heartbeat and status until the
+row is closed. Close a row in its status cell in the turn the user's answer arrives (also when the answer is "no"),
+or when the thing is withdrawn; an empty status counts as open. A file sent with `SendUserFile` and an Artifact you publish need no row of your own: the kit hook
+`sent-file` records each in `.jackherd/sent/`, and the herd, the heartbeat and the status line list the open
+ones next to the board's rows (by file name, without an id). The herd also shows them as 📎 badges on the lane
+they belong to. Close them after the answer with `jh waiting close <id>` (or `--all`); `jh waiting` lists
+what is open, with the ids. A question that is answered in a dialog needs no row, since the dialog is the wait. A watcher event or a lane's report is no row either, unless the answer to it is
+the user's.
+
 **A new idea during a release** (the user's or your own, while a plan's phases run toward one
 release) is a line in the plan's `## Follow-ups` section, with its origin, and one line to the user:
 no dialog, no new phase. It enters the release at once only when the release would otherwise be
@@ -521,15 +540,21 @@ Question: Retry the failed check, or leave it?
 ```
 
 **A draft for review.** A lane's draft that the user reviews (a README, a page, a plan) goes in
-rounds. Show it where the user can read it: rendered, when this session can publish a page,
-otherwise the file path. Ask through `AskUserQuestion` with `multiSelect`, one option per remark,
-send the chosen remarks to the lane, and show the same place again once the lane has changed it.
-The push waits for the approval of the last round.
+rounds. Show it where the user can read it. When this session has the `Artifact` tool and `preview.publish`
+in `.jackherd/config.json` is not `false` (default `true`), render the draft with `jh preview <file>`
+(GitHub and npm side by side, external images embedded) and publish that page as a private Artifact; every
+later round updates the same URL (`url` on the publish call), so the user keeps one link. Without the tool
+(another provider, Codex) or with `preview.publish` off, send the page as a file card (`SendUserFile`) or
+tell the user to run `jh preview --open`; a bare file path is the last resort. Ask through
+`AskUserQuestion` with `multiSelect`, one option per remark, send the chosen remarks to the lane, and
+show the same place again once the lane has changed it. The push waits for the approval of the last round.
 
 **Approvals.** In a lane, a call that would open a permission dialog (an ask rule) is held by the
 approval gate hook (a project install ships it; a global install has none, and the dialog stays in
 the lane). The hook records the call, the watcher reports `approval <lane> <id> <tool> · <call>`, and
-it waits up to `guard.approvals.waitMinutes` (default 8) for the user's answer. Ask at once, one
+it waits up to `guard.approvals.waitMinutes` (default 8) for the user's answer. A subagent of your own
+session (an `implement` run you started) is held the same way, under the name `subagent-<type>-<id>`
+instead of a lane's; its dialog would otherwise open in your pane and go unnoticed. Ask at once, one
 question per request, through `AskUserQuestion`:
 
 - First read the request, `.jackherd/approvals/<id>.json` in the main checkout, and show its `tool`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jackherd",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "keywords": [
     "claude-code",
     "coding-agents",
@@ -48,6 +48,8 @@
     "!docs/gen",
     "assets",
     "!assets/icons/build.ts",
+    "!assets/icons/version.ts",
+    "!assets/branding/outline.ts",
     "recipes",
     "README.md",
     "INSTALL.md",

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/read-config.ts

@@ -13,7 +13,11 @@ export type ResolvedConfig = { config: JackherdConfig; notes: string[] }
 
 /** The line for context thresholds read as tokens from a file that still gives them as a share. */
 const sharesNote = (path: string, notes: readonly string[]): string[] =>
-  notes.length > 0 ? [`${path} gives context thresholds as a share; \`${CLI_NAME} sync\` writes them as tokens.`] : []
+  notes.length > 0
+    ? [
+        `${path} gives context thresholds as a share; \`${CLI_NAME} sync\` or \`${CLI_NAME} update\` writes them as tokens.`,
+      ]
+    : []
 
 /**
  * Parses a config file's raw JSON, filling what it leaves out from the repository (see `withDetected`) and reading

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(