jackherd 1.24.0 → 1.26.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 What changed for people who use jackherd, newest first.
 
+## 1.26.0
+
+- **"Your turn" clears what is obsolete, and says why.** A closed entry now keeps the reason it was closed (`jh waiting close <id> --reason "<text>"`, `jh waiting --closed` lists the last 24 hours). The watcher closes an older sent file by itself when the same file was sent again (`newer version: <id>`, whoever sent it) or its lane's worktree is gone (`lane removed: <name>`), and reports it as `waiting closed`. What only looks obsolete is proposed once as `waiting obsolete?`: a send whose lane's pull request was merged or closed, a board row naming such a pull request or a removed lane, a question a later dialog answered in nearly the same words (`superseded`) and a question whose session ended (`session ended`). Nothing but a send is ever closed without you. A refusal by another hook is no longer recorded as an open question. New hook `question-session-end` (on `SessionEnd`) marks the ending session's open questions. The orchestrate skill's `waiting.md` and `events.md` say how to work through a proposal. Run `jh sync` to get the hook and the texts.
+
+## 1.25.0
+
+- **Every plan phase says in one sentence what it is about.** The plan template puts a line directly under each `### Phase` heading, `**What it is about:** <sentence>` (German: `**Worum es geht:** <Satz>`): what is different afterwards and for whom, or "nothing visible". `jh check` fails a phase the change adds that has tasks and no such line; phases a plan already had are not read, so older plans stay green. `jh plan check` prints a sixth line, `purpose: present` or `purpose: missing <file>:<line> no purpose line in P2, P3`; like the head it is a note and never changes the exit code. In an opened lane the herd shows the sentence dimmed under the head of each phase it draws; the folded row and the sidebar title stay as they are. The plan skill (§ structure), the herd reference and `docs/plan-contract.md` describe it. Run `jh sync` to get the template and the skill text.
+- **A board and a plan are read in every language, and the language jh writes the board in is its own setting.** A German board next to an English plan (or the other way round) used to leave "Your turn" empty and `jh plan check` red, because every heading, column name and status word was compared with the one language in `planLanguage`. jackherd now reads both languages whatever the config says, and a document in a third language carries a marker, `<!-- jh: <key> -->`, which Markdown does not show: on the line under a heading (`lanes`, `history`, `for-you`, …), in a header cell (`depends-on`, `status`, …), on a head line, in a status cell (`status-open`, `status-done`, …) and on a line that opens with bold words (`purpose`, `no-review-gate`). New `boardLanguage` in `.jackherd/config.json` is the language jh writes the board in; it defaults to `planLanguage`, so a config without it runs unchanged. A plan template renders in the language of its file name (the English file is no longer filled with German headings under a German `planLanguage`). When no section is recognised, `jh plan check` names the forms it looked for, `jh check` warns on a changed file jh reads nothing of, and the herd shows `board: no section recognised` instead of "nothing waits for you". `docs/plan-contract.md` lists the keys. Run `jh sync` to get the template and the skill text.
+
 ## 1.24.0
 
 - **A shared backend for all lanes: `lanes.backend` and `jh backend`.** With herdr, the services every lane's app talks to run in one pane (its own tab) of the main checkout, which the watcher starts at its start and once a minute, and starts again after it ended, at most three times in ten minutes. `lanes.backend` takes a `command` that contains `{services}`, a list of `services` (`name`, `port`, both unique) and an optional pane `label`; the command line starts with `env -u PORT`. A service port that something listens on prevents a start and is never freed. The pane keeps running when the watcher ends, even after `kit updated`; what was last started is kept in `backend.json` in the watcher's directory, so a restart of the watcher leaves a pane with that command alone. `jh backend` shows pane, command, handed-over services and starts; `jh backend restart` starts again after "gave up"; `jh backend release <service> --lane <lane>` stops the pane, starts it without that service and names the port for `jh lane dev <lane> --filter <service> --port <port>`; `jh backend return <service>` takes it back, and the watcher does it once the lane's worktree is gone. Only the process in the pane with the backend's label, in the main checkout, is ever stopped (SIGTERM to its foreground process group). A service name or label must be one shell word that does not start with a dash, and `jh lane dev --filter` now refuses a leading dash too. The orchestrate skill (§ 3, § 7, the `backend:` lines in its events reference) tells the coordinator when to hand a service over. A jackherd older than this version refuses a config that has `lanes.backend`: run `jh update` on every machine first, then `jh sync` for the skill text.

package/INSTALL.md

@@ -55,7 +55,7 @@ When `init` creates a new config, it asks:
 | Use it when | the team shares the kit through the repository | the repository must stay untouched, not even untracked files |
 | Lives in | the project's `.claude/` | `~/.claude/` |
 | Skill names | `/plan`, `/implement`, `/orchestrate`, … | `/jh-plan`, `/jh-implement`, `/jh-orchestrate`, … |
-| Hooks | `git-guard`, `watch-guard`, `lane-start-guard`, `merge-guard`, `approval-gate`, `model-gate`, `model-log`, `ask-hint`, `open-question`, `plain-question`, `sent-file`, `browser-guard`, `format-on-edit` | none; `init --global` offers only a `SessionStart` update notice |
+| Hooks | `git-guard`, `watch-guard`, `lane-start-guard`, `merge-guard`, `approval-gate`, `model-gate`, `model-log`, `ask-hint`, `open-question`, `question-session-end`, `plain-question`, `sent-file`, `browser-guard`, `format-on-edit` | none; `init --global` offers only a `SessionStart` update notice |
 | Config | `.jackherd/config.json` | `~/.jackherd/config.json`, used where a repository has none |
 | Update | `jh sync` | `jh update` |
 

package/README.md

@@ -1,9 +1,9 @@
 <p>
-<img alt="jackherd: a black and white Shih Tzu in a turquoise bandana, three lanes running from him to three agent nodes" src="https://unpkg.com/jackherd@1.24.0/assets/branding/jackherd-logo-outline.svg" width="340">
+<img alt="jackherd: a black and white Shih Tzu in a turquoise bandana, three lanes running from him to three agent nodes" src="https://unpkg.com/jackherd@1.26.0/assets/branding/jackherd-logo-outline.svg" width="340">
 <br>
 </p>
 
-[![npm](https://img.shields.io/npm/v/jackherd)](https://www.npmjs.com/package/jackherd) [![license: MIT](https://img.shields.io/npm/l/jackherd)](https://www.npmjs.com/package/jackherd) [![2 dependencies](https://img.shields.io/badge/dependencies-2-brightgreen)](https://www.npmjs.com/package/jackherd?activeTab=dependencies) [![macOS](https://img.shields.io/badge/macOS-supported-brightgreen?logo=apple)](https://unpkg.com/jackherd/INSTALL.md) [![Linux](https://img.shields.io/badge/Linux-supported-brightgreen?logo=linux&logoColor=white)](https://unpkg.com/jackherd/INSTALL.md)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.24.0/assets/icons/space.svg">
+[![npm](https://img.shields.io/npm/v/jackherd)](https://www.npmjs.com/package/jackherd) [![license: MIT](https://img.shields.io/npm/l/jackherd)](https://www.npmjs.com/package/jackherd) [![2 dependencies](https://img.shields.io/badge/dependencies-2-brightgreen)](https://www.npmjs.com/package/jackherd?activeTab=dependencies) [![macOS](https://img.shields.io/badge/macOS-supported-brightgreen?logo=apple)](https://unpkg.com/jackherd/INSTALL.md) [![Linux](https://img.shields.io/badge/Linux-supported-brightgreen?logo=linux&logoColor=white)](https://unpkg.com/jackherd/INSTALL.md)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.26.0/assets/icons/space.svg">
 
 # Jack herds your coding agents.
 
@@ -15,29 +15,29 @@ For developers who'd rather decide than supervise.
 curl -fsSL https://unpkg.com/jackherd/install.sh | sh
 ```
 
-Then `/jh-start` in a repository, and Jack offers your first plan. → [Quickstart](#quickstart)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.24.0/assets/icons/space.svg">
+Then `/jh-start` in a repository, and Jack offers your first plan. → [Quickstart](#quickstart)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.26.0/assets/icons/space.svg">
 
 <p>
-<img src="https://unpkg.com/jackherd@1.24.0/docs/workflow-dark.svg" width="720" alt="jackherd in herdr: a lane hits a question, Jack asks you as a choice, you pick, and the lane works on while the herd view counts its progress.">
+<img src="https://unpkg.com/jackherd@1.26.0/docs/workflow-dark.svg" width="720" alt="jackherd in herdr: a lane hits a question, Jack asks you as a choice, you pick, and the lane works on while the herd view counts its progress.">
 <br>
-<sub>Jack and his lanes in <a href="https://herdr.dev/">herdr</a>, a terminal for coding agents (recommended). Without it, one Claude Code session builds with subagents.</sub><br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.24.0/assets/icons/space.svg">
+<sub>Jack and his lanes in <a href="https://herdr.dev/">herdr</a>, a terminal for coding agents (recommended). Without it, one Claude Code session builds with subagents.</sub><br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.26.0/assets/icons/space.svg">
 </p>
 
-<p><img src="https://unpkg.com/jackherd@1.24.0/assets/icons/lanes.svg" width="24" height="34" align="middle" alt=""> <b>Parallel where it pays.</b><br>Phases that don't collide run side by side, each lane on its own branch and worktree. Jack keeps the merge order and has the others rebase.</p>
+<p><img src="https://unpkg.com/jackherd@1.26.0/assets/icons/lanes.svg" width="24" height="34" align="middle" alt=""> <b>Parallel where it pays.</b><br>Phases that don't collide run side by side, each lane on its own branch and worktree. Jack keeps the merge order and has the others rebase.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.24.0/assets/icons/decide.svg" width="24" height="34" align="middle" alt=""> <b>You make the calls.</b><br>Commits, pushes and merges wait for your approval. Jack merges on green checks only where you said so: one pull request, or a plan's for up to 24 hours. The guards catch mistakes, not intent; a hard boundary takes branch protection.</p>
+<p><img src="https://unpkg.com/jackherd@1.26.0/assets/icons/decide.svg" width="24" height="34" align="middle" alt=""> <b>You make the calls.</b><br>Commits, pushes and merges wait for your approval. Jack merges on green checks only where you said so: one pull request, or a plan's for up to 24 hours. The guards catch mistakes, not intent; a hard boundary takes branch protection.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.24.0/assets/icons/bark.svg" width="24" height="34" align="middle" alt=""> <b>Jack barks.</b><br>A lane gets stuck, a check goes red, a decision needs you: Jack steps in and brings you only what's yours to decide. The herd view shows where every lane stands.</p>
+<p><img src="https://unpkg.com/jackherd@1.26.0/assets/icons/bark.svg" width="24" height="34" align="middle" alt=""> <b>Jack barks.</b><br>A lane gets stuck, a check goes red, a decision needs you: Jack steps in and brings you only what's yours to decide. The herd view shows where every lane stands.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.24.0/assets/icons/skills.svg" width="24" height="34" align="middle" alt=""> <b>Works with your skills.</b><br>Keep your own skills: a lane builds with whichever one you pick. Plans written elsewhere run too, once Jack fills in what they're missing.</p>
+<p><img src="https://unpkg.com/jackherd@1.26.0/assets/icons/skills.svg" width="24" height="34" align="middle" alt=""> <b>Works with your skills.</b><br>Keep your own skills: a lane builds with whichever one you pick. Plans written elsewhere run too, once Jack fills in what they're missing.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.24.0/assets/icons/ear.svg" width="24" height="34" align="middle" alt=""> <b>Jack listens.</b><br>Review comments on a lane's pull request go back to that lane, which fixes them with a test. <code>/jh-follow</code> brings in anything a CLI or an API can read as JSON: tickets, error logs, status pages.</p>
+<p><img src="https://unpkg.com/jackherd@1.26.0/assets/icons/ear.svg" width="24" height="34" align="middle" alt=""> <b>Jack listens.</b><br>Review comments on a lane's pull request go back to that lane, which fixes them with a test. <code>/jh-follow</code> brings in anything a CLI or an API can read as JSON: tickets, error logs, status pages.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.24.0/assets/icons/model.svg" width="24" height="34" align="middle" alt=""> <b>The right model for each phase.</b><br>Every phase names its model: the stronger one where a mistake is expensive (data, security, a migration), the cheaper one for the rest. Lanes start on it, and a hook refuses to start a phase's subagent on a weaker one.</p>
+<p><img src="https://unpkg.com/jackherd@1.26.0/assets/icons/model.svg" width="24" height="34" align="middle" alt=""> <b>The right model for each phase.</b><br>Every phase names its model: the stronger one where a mistake is expensive (data, security, a migration), the cheaper one for the rest. Lanes start on it, and a hook refuses to start a phase's subagent on a weaker one.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.24.0/assets/icons/bowl.svg" width="24" height="34" align="middle" alt=""> <b>A crash or a full context doesn't cost you the work.</b><br>Plan, board and a hand-over file hold the state, not the chat: the next session picks up where the last one stopped.</p>
+<p><img src="https://unpkg.com/jackherd@1.26.0/assets/icons/bowl.svg" width="24" height="34" align="middle" alt=""> <b>A crash or a full context doesn't cost you the work.</b><br>Plan, board and a hand-over file hold the state, not the chat: the next session picks up where the last one stopped.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.24.0/assets/icons/plan.svg" width="24" height="34" align="middle" alt=""> <b>Lives in your repository.</b><br>Plans, board and every decision are Markdown, reviewed like code. <code>jh init</code> gives your team the same setup.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.24.0/assets/icons/space.svg"></p>
+<p><img src="https://unpkg.com/jackherd@1.26.0/assets/icons/plan.svg" width="24" height="34" align="middle" alt=""> <b>Lives in your repository.</b><br>Plans, board and every decision are Markdown, reviewed like code. <code>jh init</code> gives your team the same setup.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.26.0/assets/icons/space.svg"></p>
 
 ## Quickstart
 
@@ -68,22 +68,22 @@ Then `/jh-start` in a repository, and Jack offers your first plan. → [Quicksta
    /jh-orchestrate docs/plans/board-<name>/board.md
    ```
 
-Linux and macOS are supported (Windows through WSL); the requirements are in [INSTALL.md](https://unpkg.com/jackherd/INSTALL.md). By hand (Bun 1.3+): `bun add -g jackherd` or `npm install -g jackherd`, then `jh init --global` for yourself, or `jh init` in a repository to give your team the same skills and guard hooks.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.24.0/assets/icons/space.svg">
+Linux and macOS are supported (Windows through WSL); the requirements are in [INSTALL.md](https://unpkg.com/jackherd/INSTALL.md). By hand (Bun 1.3+): `bun add -g jackherd` or `npm install -g jackherd`, then `jh init --global` for yourself, or `jh init` in a repository to give your team the same skills and guard hooks.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.26.0/assets/icons/space.svg">
 
 ## Follow anything you can query
 
 Tickets, error logs, status pages: if a command or an API call can read it as JSON with your login, Jack can watch it. Recipes cover Jira, Linear, GitHub issues and Projects, Sentry, Google Calendar and status pages; for anything else, `/jh-follow` writes the command with you. One yes, and every change shows up like this:
 
-<img src="https://unpkg.com/jackherd@1.24.0/docs/follow-dark.svg" width="720" alt="A source (ticket, error log or status page) has a new or changed entry; jh watch reports it to Jack; Jack puts a row into Your turn, prefixed with the source's label; its [ask] button makes Jack ask you, and then a lane works it.">
+<img src="https://unpkg.com/jackherd@1.26.0/docs/follow-dark.svg" width="720" alt="A source (ticket, error log or status page) has a new or changed entry; jh watch reports it to Jack; Jack puts a row into Your turn, prefixed with the source's label; its [ask] button makes Jack ask you, and then a lane works it.">
 
-The herd sums up your sources in one `Sources` line: new entries per source, or its last run, red while it fails; opened, a click opens an entry. One that needs you lands in Your turn under the source's label, [ask] has Jack look at it, and a ticket shows on the lane that works it.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.24.0/assets/icons/space.svg">
+The herd sums up your sources in one `Sources` line: new entries per source, or its last run, red while it fails; opened, a click opens an entry. One that needs you lands in Your turn under the source's label, [ask] has Jack look at it, and a ticket shows on the lane that works it.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.26.0/assets/icons/space.svg">
 
 ## In detail
 
 <details>
 <summary><b>What Jack does on his own, and what waits for you</b></summary>
 
-<img src="https://unpkg.com/jackherd@1.24.0/docs/lanes-dark.svg" alt="Jack prompts two lanes and asks you for decisions and approvals; the lanes send questions back as text; jh watch reads lane state, pull requests and checks and wakes Jack.">
+<img src="https://unpkg.com/jackherd@1.26.0/docs/lanes-dark.svg" alt="Jack prompts two lanes and asks you for decisions and approvals; the lanes send questions back as text; jh watch reads lane state, pull requests and checks and wakes Jack.">
 
 | On his own | After your approval | Never |
 | --- | --- | --- |
@@ -116,9 +116,9 @@ The guards catch mistakes, not intent; for that, use branch protection. The hook
 <details>
 <summary><b>Plans, boards and the skills, yours included</b></summary>
 
-A **plan** is Markdown with phases, checkbox tasks, a model and a review gate per phase. A **board** lists the lanes of one or more plans: which phases each lane builds, on which model, after what. A **lane** is one agent session in its own git worktree (a second checkout of your repository), and **Jack** is the session in the main checkout that runs `/jh-orchestrate` on a board.
+A **plan** is Markdown with phases, checkbox tasks, a model and a review gate per phase, and under each phase heading one sentence on what is different afterwards and for whom. A **board** lists the lanes of one or more plans: which phases each lane builds, on which model, after what. A **lane** is one agent session in its own git worktree (a second checkout of your repository), and **Jack** is the session in the main checkout that runs `/jh-orchestrate` on a board.
 
-<img src="https://unpkg.com/jackherd@1.24.0/docs/skills-dark.svg" alt="Your own plan or an issue is adopted (Jack adds what is missing, you see the diff) and goes to /jh-orchestrate; /jh-grill hands decisions to /jh-plan; /jh-plan feeds /jh-orchestrate or a single /jh-implement, which your own skill can replace; /jh-implement ends in /jh-pre-commit, which runs the reviewers; /jh-diagnose hands a red command to /jh-implement.">
+<img src="https://unpkg.com/jackherd@1.26.0/docs/skills-dark.svg" alt="Your own plan or an issue is adopted (Jack adds what is missing, you see the diff) and goes to /jh-orchestrate; /jh-grill hands decisions to /jh-plan; /jh-plan feeds /jh-orchestrate or a single /jh-implement, which your own skill can replace; /jh-implement ends in /jh-pre-commit, which runs the reviewers; /jh-diagnose hands a red command to /jh-implement.">
 
 | Skill | Does |
 | --- | --- |
@@ -185,7 +185,7 @@ How the herd reads the board:
 - **Sources** shows, per source that is no ticket, its entries and how many are new, or when it last ran: amber with a new entry that is not in Your turn yet, red while it fails. Opened, its entries stand newest first by the time they show, and a click on an entry opens it; `↑ in your turn` marks one a row of Your turn asks about.
 - **Lanes** opens at the start. A lane that works or is blocked opens by itself only when it first appears; after that, opening and folding are yours. A lane symbol says the state (`●` working, `◆` blocked, `◉` the agent finished its answer, `○` idle, `(·) no agent` a worktree nobody works in); only blocked wears its word. A folded lane line opens with its status and the age of its last activity: `needs you 3 min` and the first open question of its report (`+2 questions` counts the others), `blocked 3 min` and what it waits on (a row of Your turn, or the lane's starts-after cell), or `running 3 min` and its step. The plan's short title and the phase as `P2/5` with its name follow, and the plan is the first part to give way in a narrow pane. A resting lane without a known reason keeps `idle · no reason`. `:3100 ↗` on the branch line of an open lane opens its dev server, while one listens on the port its board row names.
 - **Waiting** lists the lanes not started yet: no worktree yet, something left to do, and what each starts after; it starts folded. Finished lanes (cleaned up, or every phase they name ticked) are not shown.
-- **An open lane** shows, top down: its branch, the model and how long it idles; its link chips on one line, `+n` for the rest; its pull requests; the phases it works on, each with its bar and its tasks as a checklist in plan order (ticked above, the running one marked, the ones to come below; above seven tasks a window around the running one, with `… n more` above and below to open the whole list); `▸ next` with the phases that wait, as ranges; `▸ done` with the finished ones. A lane shows only the phases its board rows name; a lane without a worktree reads its plan from the main checkout. A folded lane shows a reported task below its line while it has the mouse; behind each pull request badge it shows the checks, also while the lane rests: `✓ checks`, `checks running`, `✗ test +1` with the first red check, `draft` for a draft.
+- **An open lane** shows, top down: its branch, the model and how long it idles; its link chips on one line, `+n` for the rest; its pull requests; the phases it works on, each with its bar, its purpose sentence dimmed under the head, and its tasks as a checklist in plan order (ticked above, the running one marked, the ones to come below; above seven tasks a window around the running one, with `… n more` above and below to open the whole list); `▸ next` with the phases that wait, as ranges; `▸ done` with the finished ones. A lane shows only the phases its board rows name; a lane without a worktree reads its plan from the main checkout. A folded lane shows a reported task below its line while it has the mouse; behind each pull request badge it shows the checks, also while the lane rests: `✓ checks`, `checks running`, `✗ test +1` with the first red check, `draft` for a draft.
 - **A phase runs** when an agent reports working on it, one of its boxes was ticked in the last 20 minutes, or some of its tasks are ticked. A phase whose run was merged and that the lane's newest board row no longer names waits behind the others in `▸ next`, its open boxes left open on purpose. `n min ago` counts since the last tick or report; `· gate` means only the review gate is open, `docs open` only the documentation box.
 - **A running task** carries `●` when an agent reported it, from its task list or `jh task`; its text stands in teal and a light band runs over it (`plans.shimmer: false`, `NO_COLOR` and `--once` keep it still). `◌` is a guess: in dim, a task guessed from the words of the lane's log; shimmering like a reported one, the first open task of a phase the lane runs when no agent reported one. `now: …` is a reported task no plan task names, `Subagent: …` a running subagent on no phase; a running review sits on the gate box that names it, in the phase it names or else the lane's current one. With several agents in a lane, each task carries its agent's name, dim, at the right edge.
 - **What a working lane does right now:** under its lane line, open or folded, a dim `↳` line shows the last action from the agent's session log, a tool with its target (`↳ Read plans/layout.ts`) or the start of its answer, and each running subagent adds one, indented and led by its task (where `Subagent: …` says what it works on, `↳` says what it does); the lines go when the lane rests.
@@ -223,7 +223,7 @@ jackherd sets the model, not the effort and not the advisor: those come from Cla
 | `jh init` | creates `.jackherd/config.json` and installs the kit (`--global` for `~/.claude`) |
 | `jh sync` | updates the kit; a file you edited gets the new version beside it as `.kit-new` |
 | `jh update` | installs the newest release and syncs |
-| `jh check` | types, lint and tests of what you touched, plus the plan and board checks (`--skip-slow`, `--parallel <plan>`) |
+| `jh check` | types, lint and tests of what you touched, plus the plan and board checks, among them the purpose line every new plan phase with tasks needs (`--skip-slow`, `--parallel <plan>`); `jh plan check <plan>` reports the plan contract, the purpose line as a note; boards and plans are read in English and German whatever `planLanguage` says, a third language by `<!-- jh: <key> -->` markers, and `boardLanguage` (default `planLanguage`) is the language jh writes the board in (`docs/plan-contract.md`) |
 | `jh herd` | the live view (`--once`, `--lane <name>`) |
 | `jh watch` | the watcher Jack runs |
 | `jh resume` | after herdr restarts, wakes the coordinator and the lanes that worked when the machine crashed; runs once per crash and only when the watcher's record shows no `stoppedAt`. Stopping the watcher before quitting herdr prevents it. With `--coordinator` it lists what a coordinator takes up after `/clear` (lanes, PRs, approvals, what waits on you, appointments, standing approvals), from files and herdr; `--clear-line` prints the first input of that chat. |
@@ -232,7 +232,7 @@ jackherd sets the model, not the effort and not the advisor: those come from Cla
 | `jh lane close <lane>` | removes a finished lane: agent, worktree, herdr workspace and branch, and marks the board; first checks that nothing is lost, and refuses with every reason; `--dry-run` only checks. Runs without a prompt. |
 | `jh backend` | the shared backend of the lanes (`lanes.backend`, one pane in the main checkout that the watcher keeps): shows its pane, command and handed-over services; `restart`; `release <service> --lane <lane>` stops it and starts it without that service, naming the port the lane starts it on; `return <service>`. Works from any worktree. A busy service port stops a start, nothing frees a port |
 | `jh preview <file>` | renders a Markdown file through the GitHub API into a preview in GitHub and npm style |
-| `jh waiting` | the files and Artifacts sent to you that you have not answered yet (`close <id>…` or `close --all` once you have) |
+| `jh waiting` | the files and Artifacts sent to you that you have not answered yet (`close <id>… [--reason "<text>"]` or `close --all` once you have; `--closed` lists what closed in the last 24 hours with its reason). The watcher closes an older send by itself once the same file was sent again or its lane is gone, and proposes the rest (a merged pull request, a question that looks answered, a session that ended) as `waiting obsolete?` |
 | `jh brief` | three lines for each open lane of the board: its goal, its status and what it needs from you, read from the head of its plan (`--board <board.md>` names the board); after `plans.briefAfterMinutes` (default 60, 0 is off) without a prompt, the `return-brief` hook asks Jack to show it first |
 | `jh context` | how full an agent's context is, as JSON; `--usage [--since 24h\|7d\|<date>]` the tokens a lane used instead (Jack's with `--coordinator`) |
 | `jh config` | the commands and the base branch the repository uses; a missing value goes to stderr with the line to set, and `jh config <key>` for an unset value exits 3 |

package/dist/{chunk-JDO6O3UO.js → chunk-O365KHHP.js}

@@ -1,5 +1,9 @@
 // src/vocabulary/index.ts
 var PLAN_LANGUAGE = { de: "de", en: "en" };
+var languagesFrom = (language) => [
+  language,
+  ...Object.values(PLAN_LANGUAGE).filter((other) => other !== language)
+];
 var LANGUAGE_NAME = {
   [PLAN_LANGUAGE.en]: "English",
   [PLAN_LANGUAGE.de]: "German"
@@ -87,6 +91,73 @@ var WAITING_VOCABULARY = {
     open: ["open"]
   }
 };
+var SECTION_KEY = {
+  waiting: "waiting",
+  appointments: "appointments",
+  lanes: "lanes",
+  goal: "goal",
+  history: "history",
+  plans: "plans",
+  decisions: "decisions",
+  implementation: "implementation",
+  model: "model",
+  dependencies: "dependencies",
+  documentation: "documentation",
+  forYou: "for-you",
+  next: "next"
+};
+var isSectionKey = (value) => Object.values(SECTION_KEY).includes(value);
+var HEAD_KEY = {
+  changes: "head-changes",
+  status: "head-status",
+  decisions: "head-decisions",
+  tryNow: "head-try-now",
+  next: "head-next"
+};
+var LINE_KEY = { noReviewGate: "no-review-gate", purpose: "purpose" };
+var COLUMN_KEY = {
+  since: "since",
+  item: "item",
+  origin: "origin",
+  unblocks: "unblocks",
+  status: "status",
+  when: "when",
+  action: "action",
+  dependsOn: "depends-on",
+  writes: "writes",
+  serialMarker: "serial-marker"
+};
+var columnWords = (key, language) => {
+  const waiting = WAITING_VOCABULARY[language];
+  const appointments = APPOINTMENT_VOCABULARY[language];
+  const { columns } = PLAN_VOCABULARY[language];
+  const words = {
+    [COLUMN_KEY.since]: [waiting.columns.since],
+    [COLUMN_KEY.item]: [waiting.columns.item],
+    [COLUMN_KEY.origin]: [waiting.columns.origin],
+    [COLUMN_KEY.unblocks]: [waiting.columns.unblocks],
+    [COLUMN_KEY.status]: [
+      waiting.columns.status,
+      ...waiting.statusAlso,
+      appointments.columns.status,
+      ...appointments.statusAlso
+    ],
+    [COLUMN_KEY.when]: [appointments.columns.when],
+    [COLUMN_KEY.action]: [appointments.columns.action],
+    [COLUMN_KEY.dependsOn]: [columns.dependsOn],
+    [COLUMN_KEY.writes]: [columns.writes],
+    [COLUMN_KEY.serialMarker]: [columns.serialMarker]
+  };
+  return words[key];
+};
+var STATUS_KEY = {
+  open: "status-open",
+  done: "status-done",
+  abandoned: "status-abandoned",
+  inProgress: "status-in-progress",
+  draft: "status-draft"
+};
+var isStatusKey = (value) => Object.values(STATUS_KEY).includes(value);
 var isPlanLanguage = (value) => Object.values(PLAN_LANGUAGE).includes(value);
 var PLAN_STATUS = {
   done: "done",
@@ -138,6 +209,7 @@ var PLAN_VOCABULARY = {
     columns: { dependsOn: "H\xE4ngt ab von", writes: "Schreibt", serialMarker: "Seriell-Marker" },
     phase: "Phase",
     noReviewGate: "Kein Review-Gate",
+    phasePurpose: "Worum es geht",
     laneClosed: "abger\xE4umt",
     partialPhase: "(Teil)",
     openSubagents: "offene Sub-Agenten",
@@ -181,6 +253,7 @@ var PLAN_VOCABULARY = {
     columns: { dependsOn: "Depends on", writes: "Writes", serialMarker: "Serial marker" },
     phase: "Phase",
     noReviewGate: "No review gate",
+    phasePurpose: "What it is about",
     laneClosed: "cleaned up",
     partialPhase: "(part)",
     openSubagents: "open subagents",
@@ -202,15 +275,63 @@ var PLAN_VOCABULARY = {
   }
 };
 var STATUS_PRECEDENCE = [PLAN_STATUS.done, PLAN_STATUS.abandoned, PLAN_STATUS.inProgress, PLAN_STATUS.draft];
-var classifyStatus = (language, statusText) => {
+var STATUS_OF_KEY = {
+  [STATUS_KEY.done]: PLAN_STATUS.done,
+  [STATUS_KEY.abandoned]: PLAN_STATUS.abandoned,
+  [STATUS_KEY.inProgress]: PLAN_STATUS.inProgress,
+  [STATUS_KEY.draft]: PLAN_STATUS.draft
+};
+var MARKER_IN_TEXT = /<!--\s*jh:\s*([a-z-]+)\s*-->/;
+var statusOfMarker = (statusText) => {
+  const key = MARKER_IN_TEXT.exec(statusText)?.[1];
+  return key !== void 0 && isStatusKey(key) ? STATUS_OF_KEY[key] : void 0;
+};
+var statusOfWords = (language, statusText) => {
   const { statusWords } = PLAN_VOCABULARY[language];
   const lowerStatus = statusText.toLowerCase();
   const matches = ({ leading, anywhere }) => leading.some((word) => lowerStatus.startsWith(word)) || anywhere.some((fragment) => lowerStatus.includes(fragment));
-  const matched = STATUS_PRECEDENCE.find((status) => matches(statusWords[status]));
+  return STATUS_PRECEDENCE.find((status) => matches(statusWords[status]));
+};
+var classifyStatus = (language, statusText) => {
+  const marked = statusOfMarker(statusText);
+  if (marked) return marked;
+  const text = statusText.replace(MARKER_IN_TEXT, "");
+  const matched = languagesFrom(language).map((candidate) => statusOfWords(candidate, text)).find((status) => status !== void 0);
   if (matched) return matched;
-  return statusText.trim() ? PLAN_STATUS.other : PLAN_STATUS.none;
+  return text.trim() ? PLAN_STATUS.other : PLAN_STATUS.none;
 };
 var phaseHeading = (language, id, title) => `### ${PLAN_VOCABULARY[language].phase} ${id}: ${title}`;
+var headingOfSection = (key, language) => {
+  const { sections } = PLAN_VOCABULARY[language];
+  const headings = {
+    [SECTION_KEY.waiting]: WAITING_VOCABULARY[language].heading,
+    [SECTION_KEY.appointments]: APPOINTMENT_VOCABULARY[language].heading,
+    [SECTION_KEY.lanes]: sections.lanes,
+    [SECTION_KEY.goal]: sections.goal,
+    [SECTION_KEY.history]: sections.history,
+    [SECTION_KEY.plans]: sections.plans,
+    [SECTION_KEY.decisions]: sections.decisions,
+    [SECTION_KEY.implementation]: sections.implementation,
+    [SECTION_KEY.model]: sections.modelRecommendations,
+    [SECTION_KEY.dependencies]: sections.dependencies,
+    [SECTION_KEY.documentation]: sections.documentation,
+    [SECTION_KEY.forYou]: sections.forYou,
+    [SECTION_KEY.next]: NEXT_VOCABULARY[language].heading
+  };
+  return headings[key];
+};
+var sectionOfHeading = (headingText) => {
+  for (const language of Object.values(PLAN_LANGUAGE)) {
+    const key = Object.values(SECTION_KEY).find((candidate) => headingOfSection(candidate, language) === headingText);
+    if (key !== void 0) return { key, language };
+  }
+  return null;
+};
+var CELL_KEY = { laneClosed: "lane-closed", partialPhase: "partial-phase" };
+var LANE_CLOSED_WORDS = Object.values(PLAN_VOCABULARY).map(({ laneClosed }) => laneClosed);
+var PARTIAL_PHASE_WORDS = Object.values(PLAN_VOCABULARY).map(
+  ({ partialPhase }) => partialPhase
+);
 var sectionHeading = (language, section) => `## ${PLAN_VOCABULARY[language].sections[section]}`;
 
 // src/plan-format/terminal-text.ts
@@ -232,6 +353,7 @@ var terminalSafe = (text) => text.replace(UNSAFE_TERMINAL_TEXT, "");
 
 export {
   PLAN_LANGUAGE,
+  languagesFrom,
   LANGUAGE_NAME,
   RESPONSE_ADDRESS,
   ADDRESS_FORM,
@@ -244,13 +366,27 @@ export {
   APPOINTMENT_VOCABULARY,
   NEXT_VOCABULARY,
   WAITING_VOCABULARY,
+  SECTION_KEY,
+  isSectionKey,
+  HEAD_KEY,
+  LINE_KEY,
+  COLUMN_KEY,
+  columnWords,
+  STATUS_KEY,
+  isStatusKey,
   isPlanLanguage,
   PLAN_STATUS,
   REPORT_FIELDS,
   HEAD_LINE,
   PLAN_VOCABULARY,
+  MARKER_IN_TEXT,
   classifyStatus,
   phaseHeading,
+  headingOfSection,
+  sectionOfHeading,
+  CELL_KEY,
+  LANE_CLOSED_WORDS,
+  PARTIAL_PHASE_WORDS,
   sectionHeading,
   terminalSafe
 };

package/dist/config.d.ts

@@ -95,6 +95,10 @@ declare const jackherdConfigSchema: z.ZodObject<{
         de: "de";
         en: "en";
     }>>;
+    boardLanguage: z.ZodOptional<z.ZodEnum<{
+        de: "de";
+        en: "en";
+    }>>;
     planDirectory: z.ZodDefault<z.ZodString>;
     board: z.ZodPrefault<z.ZodObject<{
         pattern: z.ZodDefault<z.ZodString>;

package/dist/config.js

@@ -1,7 +1,7 @@
 import {
   PLAN_LANGUAGE,
   RESPONSE_ADDRESS
-} from "./chunk-JDO6O3UO.js";
+} from "./chunk-O365KHHP.js";
 
 // src/config/json-schema.ts
 import { z as z4 } from "zod";
@@ -720,7 +720,10 @@ var jackherdConfigSchema = z3.strictObject({
   responseLanguage: language.default(PLAN_LANGUAGE.en),
   /** Whether replies address the user with the familiar or the polite form where the language has both (German: du or Sie). */
   responseAddress: z3.enum(Object.values(RESPONSE_ADDRESS)).default(RESPONSE_ADDRESS.informal),
+  /** The language new plans and the plan templates are written in. Boards and plans are read in every known language whatever this says. */
   planLanguage: language.default(PLAN_LANGUAGE.en),
+  /** The language jh writes the board in (history lines, lane rows, waiting rows); `planLanguage` when left out. */
+  boardLanguage: language.optional(),
   planDirectory: z3.string().min(1).default("docs/plans"),
   /** Where the boards live and what the project calls them. */
   board: boardSchema.prefault({}),

package/dist/plan-format.d.ts

@@ -3,6 +3,8 @@ declare const PLAN_LANGUAGE: {
     readonly en: "en";
 };
 type PlanLanguage = (typeof PLAN_LANGUAGE)[keyof typeof PLAN_LANGUAGE];
+/** The languages to try when reading: `language` first, then every other known one. */
+declare const languagesFrom: (language: PlanLanguage) => PlanLanguage[];
 /** The language's name as a reply or a question says it. */
 declare const LANGUAGE_NAME: Record<PlanLanguage, string>;
 declare const RESPONSE_ADDRESS: {
@@ -106,6 +108,73 @@ declare const WAITING_VOCABULARY: Record<PlanLanguage, {
     statusAlso: readonly string[];
     open: readonly string[];
 }>;
+/**
+ * The closed set of keys a section carries in a marker, `<!-- jh: <key> -->` on the line directly under its heading.
+ * The marker names the section whatever language the heading is written in.
+ */
+declare const SECTION_KEY: {
+    readonly waiting: "waiting";
+    readonly appointments: "appointments";
+    readonly lanes: "lanes";
+    readonly goal: "goal";
+    readonly history: "history";
+    readonly plans: "plans";
+    readonly decisions: "decisions";
+    readonly implementation: "implementation";
+    readonly model: "model";
+    readonly dependencies: "dependencies";
+    readonly documentation: "documentation";
+    readonly forYou: "for-you";
+    readonly next: "next";
+};
+type SectionKey = (typeof SECTION_KEY)[keyof typeof SECTION_KEY];
+declare const isSectionKey: (value: string) => value is SectionKey;
+/**
+ * The marker key of each line of the head section (`- **Stand:** <!-- jh: head-status --> …`). The marker names the
+ * line whatever language its label is written in.
+ */
+declare const HEAD_KEY: Record<HeadLine, string>;
+/**
+ * The closed set of keys a line that opens with bold words carries in a marker
+ * (`**Kein Review-Gate** <!-- jh: no-review-gate --> reason`). The marker names the line whatever language it is in.
+ */
+declare const LINE_KEY: {
+    readonly noReviewGate: "no-review-gate";
+    readonly purpose: "purpose";
+};
+/**
+ * The closed set of keys a table column carries in a marker in its header cell (`Hängt ab von <!-- jh: depends-on -->`).
+ * The marker names the column whatever language the header is written in.
+ */
+declare const COLUMN_KEY: {
+    readonly since: "since";
+    readonly item: "item";
+    readonly origin: "origin";
+    readonly unblocks: "unblocks";
+    readonly status: "status";
+    readonly when: "when";
+    readonly action: "action";
+    readonly dependsOn: "depends-on";
+    readonly writes: "writes";
+    readonly serialMarker: "serial-marker";
+};
+type ColumnKey = (typeof COLUMN_KEY)[keyof typeof COLUMN_KEY];
+/** The header names the column `key` goes by in `language`: its name first, then the names that count as the same column. */
+declare const columnWords: (key: ColumnKey, language: PlanLanguage) => readonly string[];
+/**
+ * The closed set of keys a status carries in a marker in its cell (`erledigt <!-- jh: status-done -->`): `open` for a
+ * board row that still waits, the others for the status of a plan. The marker names the status whatever language the
+ * cell is written in.
+ */
+declare const STATUS_KEY: {
+    readonly open: "status-open";
+    readonly done: "status-done";
+    readonly abandoned: "status-abandoned";
+    readonly inProgress: "status-in-progress";
+    readonly draft: "status-draft";
+};
+type StatusKey = (typeof STATUS_KEY)[keyof typeof STATUS_KEY];
+declare const isStatusKey: (value: string) => value is StatusKey;
 declare const isPlanLanguage: (value: string) => value is PlanLanguage;
 declare const PLAN_STATUS: {
     readonly done: "done";
@@ -173,6 +242,8 @@ type PlanVocabulary = {
     phase: string;
     /** Opens the line by which a phase says it has no review gate on purpose: `**Kein Review-Gate:** <reason>`. */
     noReviewGate: string;
+    /** Opens the line directly under a phase heading that says in one sentence what is different afterwards, for whom: `**Worum es geht:** <sentence>`. */
+    phasePurpose: string;
     /** Marks a lane as closed when its name cell contains it. */
     laneClosed: string;
     /** Stands in a board row's phases cell when that pull request builds only part of the phase. */
@@ -196,10 +267,35 @@ type PlanVocabulary = {
     statusWords: Record<PlanStatus, StatusWord>;
 };
 declare const PLAN_VOCABULARY: Record<PlanLanguage, PlanVocabulary>;
-/** Classifies a free-text `Status:` line; the first matching status in precedence order wins. */
+/** A `<!-- jh: <key> -->` marker anywhere in a text; the key is group 1. */
+declare const MARKER_IN_TEXT: RegExp;
+/**
+ * Classifies a free-text `Status:` line. A status marker (`<!-- jh: status-done -->`) decides, any language; else the
+ * first matching status in precedence order of the words of `language`, then of any other known language.
+ */
 declare const classifyStatus: (language: PlanLanguage, statusText: string) => PlanStatus;
 /** `### Phase 3: Title` as the plan spells it in `language`. */
 declare const phaseHeading: (language: PlanLanguage, id: string, title: string) => string;
+/** The heading text of the section `key` names, as `language` writes it. */
+declare const headingOfSection: (key: SectionKey, language: PlanLanguage) => string;
+/** The key and language of the section a heading text names, read the way a caller spells it; `null` when no language does. */
+declare const sectionOfHeading: (headingText: string) => {
+    key: SectionKey;
+    language: PlanLanguage;
+} | null;
+/**
+ * The closed set of keys a lanes-table cell carries in a marker: `lane-closed` in the name cell of a lane that was
+ * cleaned up, `partial-phase` in the phases cell of a row that builds only part of a phase.
+ */
+declare const CELL_KEY: {
+    readonly laneClosed: "lane-closed";
+    readonly partialPhase: "partial-phase";
+};
+type CellKey = (typeof CELL_KEY)[keyof typeof CELL_KEY];
+/** The words of every known language that mark a lane as cleaned up. */
+declare const LANE_CLOSED_WORDS: readonly string[];
+/** The words of every known language that mark a row as building only part of a phase. */
+declare const PARTIAL_PHASE_WORDS: readonly string[];
 declare const sectionHeading: (language: PlanLanguage, section: keyof PlanVocabulary["sections"]) => string;
 
 /**
@@ -260,11 +356,13 @@ type PhaseWorkFields = {
 /**
  * `work` is set by the phase source and says nothing for a phase the worktree left as the base has it; a merged phase
  * is touched as well. `deferred` holds the checkboxes moved to another phase; they are not among `items`, so they
- * count neither as open nor as done.
+ * count neither as open nor as done. `purpose` is the sentence of the purpose line directly under a `### Phase`
+ * heading (`phasePurposeOf`); absent when the phase has none.
  */
 type PlanPhase = {
     id: string;
     title: string;
+    purpose?: string;
     items: ChecklistItem[];
     deferred?: DeferredItem[];
 } & Partial<PhaseWorkFields>;
@@ -283,6 +381,15 @@ declare const endsPhase: (line: string) => boolean;
 declare const isCheckboxLine: (line: string) => boolean;
 declare const isOpenCheckboxLine: (line: string) => boolean;
 declare const phaseHeadingPattern: (language: PlanLanguage) => RegExp;
+/** The bold opening of a line (`**Label:**` or `**Label**:`): the label and the text after it. */
+declare const BOLD_OPENING: RegExp;
+/**
+ * The sentence of a purpose line, `**Worum es geht:** <sentence>`, the colon inside or outside the bold; null for any
+ * other line and for a purpose line without text after the colon.
+ */
+declare const phasePurposeOf: (line: string, language: PlanLanguage) => string | null;
+/** The first non-empty line under a heading decides whether a phase has its purpose line; once `decided`, later lines never do. */
+declare const decidesPurpose: (decided: boolean, line: string) => boolean;
 /**
  * The phase an open checkbox line is moved to with `→ P<n>` at its end; null for any other line, a ticked box,
  * a ✅/⬜ table row, and an arrow to the box's own phase `phaseId`. The one rule the parser and the tally share.
@@ -556,6 +663,8 @@ type PhaseWithOpenBoxes = PhaseWithoutGate & {
 };
 /** A `PhaseWithOpenBoxes` whose tasks are all ticked on the base branch. */
 type MergedPhaseWithOpenBoxes = PhaseWithOpenBoxes;
+/** A `### Phase` heading (1-based line) whose section has tasks and no purpose line directly under the heading. */
+type PhaseWithoutPurpose = PhaseHeading;
 /** The ids of the `### Phase` headings of a plan. */
 declare const phaseIdsOfPlan: (markdown: string, language: PlanLanguage) => Set<string>;
 /**
@@ -565,6 +674,13 @@ declare const phaseIdsOfPlan: (markdown: string, language: PlanLanguage) => Set<
  * plan does not turn red when it is touched.
  */
 declare const newPhasesWithoutReviewGate: (markdown: string, language: PlanLanguage, previousIds: ReadonlySet<string>) => PhaseWithoutGate[];
+/**
+ * The phases a plan gained against `previousIds` that have checkboxes and no purpose line as the first non-empty line
+ * under the heading (`phasePurposeOf`). Phases the plan already had are not read, like in `newPhasesWithoutReviewGate`.
+ */
+declare const newPhasesWithoutPurpose: (markdown: string, language: PlanLanguage, previousIds: ReadonlySet<string>) => PhaseWithoutPurpose[];
+/** Every phase of the plan with tasks and without a purpose line: for a plan read whole, where no phase is older than the change. */
+declare const phasesWithoutPurpose: (markdown: string, language: PlanLanguage) => PhaseWithoutPurpose[];
 /** Whether the document has a lanes table (`## Spuren`): a board, not a plan. */
 declare const hasLanesTable: (markdown: string, language: PlanLanguage) => boolean;
 /**
@@ -593,6 +709,8 @@ declare const boardRowsWithoutPhase: (markdown: string, language: PlanLanguage,
 type PhaseProgress = {
     id: string;
     title: string | null;
+    /** The phase's purpose sentence; absent when the plan has none or lacks the phase. */
+    purpose?: string;
     done: number;
     total: number;
     items: ChecklistItem[];
@@ -709,4 +827,4 @@ declare const readSprintDocument: (markdown: string, language: PlanLanguage) =>
  */
 declare const readPhaseDependencies: (planMarkdown: string, language: PlanLanguage) => Record<string, string>;
 
-export { ADDRESS_FORM, APPOINTMENT_VOCABULARY, APPROVAL_TEXTS, CARD_FIELDS, type ChecklistItem, type ColumnModel, type DeferredItem, type DriftFinding, HEAD_LINE, HEAD_STATUS, type HeadLine, type HeadPhase, type HeadStatus, type HeadVerdict, LANE_PROMPT_OPENING, LANGUAGE_NAME, type LaneProgress, type LongPhaseTitle, type MergedPhaseWithOpenBoxes, type MisplacedDeferral, type ModelRow, NEXT_VOCABULARY, NO_DEPENDENCY_TABLE, PHASE_CELL_LIMIT, PHASE_ID_PREFIX, PHASE_TITLE_LIMIT, PHASE_WORK, PLAN_LANGUAGE, PLAN_STATUS, PLAN_VOCABULARY, PROSE_REASON, type PhaseDependency, type PhaseHeading, type PhaseProgress, type PhaseSchedule, type PhaseTally, type PhaseWithOpenBoxes, type PhaseWithoutGate, type PhaseWithoutRow, type PhaseWork, type PhaseWorkFields, type PlanHead, type PlanHeader, type PlanLanguage, type PlanPhase, type PlanStatus, type PlanStep, type PlanVocabulary, type PlansByHref, type ProseReason, RECOMMENDED_MARK, REPORT_FIELDS, RESPONSE_ADDRESS, type ResponseAddress, type RowWithProse, type RowWithoutPhase, SELF_MERGE_LABEL, SHORT_NAME_LIMIT, SHORT_NAME_PROBLEM, STANDING_APPROVAL_TEXTS, type ShortNameFinding, type ShortNameProblem, type SprintDocument, type SprintLane, type SprintPlanRow, type SprintPlanTable, type StatusWord, type StepProgress, WAITING_VOCABULARY, activeItem, boardRowsWithProse, boardRowsWithoutPhase, checkPlanHead, classifyStatus, columnModels, countDecisions, criticalPath, currentPhase, currentPhaseOf, deferralTarget, differsFromColumn, endsPhase, findDrift, hasLanesTable, isCheckboxLine, isDocumentationGateItem, isOpenCheckboxLine, isPhaseFinished, isPhaseOpen, isPlanLanguage, isReviewGateLine, isTickedUnmerged, laneNameOf, laneProgress, longPhaseTitles, mergedPhasesWithOpenBoxes, misplacedDeferrals, newPhasesWithoutReviewGate, onlyDocumentationOpen, openBoxesOfPhase, parallelGroups, parallelGroupsOfPlan, parseDependencyTable, parseModelTable, parsePlanHead, parsePlanPhases, parseSprintLanes, phaseCount, phaseHeading, phaseHeadingPattern, phaseHeadings, phaseIdOf, phaseIdsOfCell, phaseIdsOfPlan, phaseLabel, phaseLabels, phaseProgress, phaseWaves, phaseWorkFields, phasesText, phasesWithoutDependencyRow, readPhaseDependencies, readPlanHeader, readSprintDocument, resolvePlanPath, sectionHeading, shortNameFindings, shortTitle, sprintTitleOf, sumPhases, tallyPhases, wavesOfPlan, withoutRepeats };
+export { ADDRESS_FORM, APPOINTMENT_VOCABULARY, APPROVAL_TEXTS, BOLD_OPENING, CARD_FIELDS, CELL_KEY, COLUMN_KEY, type CellKey, type ChecklistItem, type ColumnKey, type ColumnModel, type DeferredItem, type DriftFinding, HEAD_KEY, HEAD_LINE, HEAD_STATUS, type HeadLine, type HeadPhase, type HeadStatus, type HeadVerdict, LANE_CLOSED_WORDS, LANE_PROMPT_OPENING, LANGUAGE_NAME, LINE_KEY, type LaneProgress, type LongPhaseTitle, MARKER_IN_TEXT, type MergedPhaseWithOpenBoxes, type MisplacedDeferral, type ModelRow, NEXT_VOCABULARY, NO_DEPENDENCY_TABLE, PARTIAL_PHASE_WORDS, PHASE_CELL_LIMIT, PHASE_ID_PREFIX, PHASE_TITLE_LIMIT, PHASE_WORK, PLAN_LANGUAGE, PLAN_STATUS, PLAN_VOCABULARY, PROSE_REASON, type PhaseDependency, type PhaseHeading, type PhaseProgress, type PhaseSchedule, type PhaseTally, type PhaseWithOpenBoxes, type PhaseWithoutGate, type PhaseWithoutPurpose, type PhaseWithoutRow, type PhaseWork, type PhaseWorkFields, type PlanHead, type PlanHeader, type PlanLanguage, type PlanPhase, type PlanStatus, type PlanStep, type PlanVocabulary, type PlansByHref, type ProseReason, RECOMMENDED_MARK, REPORT_FIELDS, RESPONSE_ADDRESS, type ResponseAddress, type RowWithProse, type RowWithoutPhase, SECTION_KEY, SELF_MERGE_LABEL, SHORT_NAME_LIMIT, SHORT_NAME_PROBLEM, STANDING_APPROVAL_TEXTS, STATUS_KEY, type SectionKey, type ShortNameFinding, type ShortNameProblem, type SprintDocument, type SprintLane, type SprintPlanRow, type SprintPlanTable, type StatusKey, type StatusWord, type StepProgress, WAITING_VOCABULARY, activeItem, boardRowsWithProse, boardRowsWithoutPhase, checkPlanHead, classifyStatus, columnModels, columnWords, countDecisions, criticalPath, currentPhase, currentPhaseOf, decidesPurpose, deferralTarget, differsFromColumn, endsPhase, findDrift, hasLanesTable, headingOfSection, isCheckboxLine, isDocumentationGateItem, isOpenCheckboxLine, isPhaseFinished, isPhaseOpen, isPlanLanguage, isReviewGateLine, isSectionKey, isStatusKey, isTickedUnmerged, laneNameOf, laneProgress, languagesFrom, longPhaseTitles, mergedPhasesWithOpenBoxes, misplacedDeferrals, newPhasesWithoutPurpose, newPhasesWithoutReviewGate, onlyDocumentationOpen, openBoxesOfPhase, parallelGroups, parallelGroupsOfPlan, parseDependencyTable, parseModelTable, parsePlanHead, parsePlanPhases, parseSprintLanes, phaseCount, phaseHeading, phaseHeadingPattern, phaseHeadings, phaseIdOf, phaseIdsOfCell, phaseIdsOfPlan, phaseLabel, phaseLabels, phaseProgress, phasePurposeOf, phaseWaves, phaseWorkFields, phasesText, phasesWithoutDependencyRow, phasesWithoutPurpose, readPhaseDependencies, readPlanHeader, readSprintDocument, resolvePlanPath, sectionHeading, sectionOfHeading, shortNameFindings, shortTitle, sprintTitleOf, sumPhases, tallyPhases, wavesOfPlan, withoutRepeats };