jackherd 1.10.0 → 1.11.0

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 What changed for people who use jackherd, newest first.
 
+## 1.11.0
+
+- **The herd lists your sources.** A `watch.sources` entry that is no ticket gets a row in a `Sources` block: when it last ran, since when it fails (red mark), its newest report (amber mark while it is under a day old); a click opens the report's URL. `/jh-follow` and `recipes/sources.md` say how.
+- **The colours of the herd are configurable.** `plans.tones` names the tone of each role (`waiting`, `new`, `running`, `resting`) from amber, teal, grey, red, green, blue and magenta; a source may carry its own `tone` for its new reports. The defaults are the colours it had.
+- **A row from a source says which one.** `watch.sources[].label` (at most 40 characters, one line; without it the source's name) is put before a "Waiting for you" row whose `Origin` cell names the source, as `<label>: <row>`.
+- **"Waiting for you" rows have `[done]`, the appointments have `[done]`, `[run]` and `[move]`.** `[done]` closes the row (the board's status cell, a sent file's record), `[run]` asks the coordinator to run the appointment now, `[move]` to ask you for a new time.
+- **New blocks and cells in the herd.** `Next` shows the board's next section; a resting lane says `waits on: …` or `after: …`; `groomed 3d ago` beside the clock (amber from eight days) from the board-grooming appointment; `planned` shows the next phase per plan, with `stale?` once its plan file has not changed on the base branch for 14 days.
+- **`jh mermaid <file>` checks the diagrams of a pull request text.** An edge label between dashes (`-- text -->`) or a pipe label without quotes makes GitHub show `Lexical error` instead of the diagram; the command exits 1 with the line. The pull request rule now says to write `-->|"label"|` and to run it before `gh pr create` or `gh pr edit`.
+- **A report that says "Keine offenen." asks nothing.** The watcher no longer counts it as a question, and a bold or listed "None." does not either.
+- **A note in the write set no longer widens it to the whole repository.** A backticked config key such as `watch.sources[].label` in the `Writes` cell of a plan's dependency table is no path, so `jh lane prompt` lists only the real folders.
+- **One colour rule for the buttons.** The buttons no longer wear the colour of the row's mark: amber and bold in "Waiting for you", the normal foreground colour in the other blocks, dim only where nothing is left to do (an entry that says `↑ asked`).
+- **A source with several entries opens on a click.** The `Sources` block shows one folded row per source (amber only for a new entry that no row of "Waiting for you" asks about); opened, it lists up to five entries with title, count (`map.count`, new) and time, then `+<n> more`. A click on an entry opens its `url`, `[ask]` asks the coordinator to look at exactly that entry, and an entry that "Waiting for you" already asks about is dim and says `↑ asked`. The watcher keeps the last 20 entries of such a source.
+- **A question put off twice stays one open question.** The `open-question` hook writes no second record while one with the same text is still open, so asking it again with `[ask]` and answering "later" again leaves a single row.
+- **A click folds the ticked tasks again.** The listed ticked tasks of a phase get a line `▾ <n> ticked · click or a folds them` above them; before, only `a` closed the list that a click had opened. The key hint and the legend name both.
+- **`jh lane prompt` keeps your additions and names no contested phase.** What you write below the marker line at the end of the prompt file stays through every new writing, `--handover` included. A phase that two open rows of the board name comes into neither prompt; the command prints it and a lane left with nothing is refused.
+- **The row under the mouse or the arrows is marked, everywhere.** Any clickable row of the herd (lane, phase, ticked line, `waiting`, `planned`, and the rows of `Waiting for you`, `Next`, `Appointments` and `Sources`) gets a light background and a `❯` in front, and its buttons turn bold; the background joins the text and its buttons across the full width. The herd now asks the terminal for mouse movement and redraws only when the row under the mouse changes. `↑↓` also walks the rows of the blocks on top; enter on one asks, opens or expands it, and never presses `[done]` or `[run]`. The legend names it.
+- **Links are bracket buttons, and the mouse bolds only the one it is on.** The links under a lane (`[↗ #<n>]  [📄 Plan]  [✦ title]`) lose the grey background and read like `[ask]`: a square bracket means a click does something. `… checks` stays plain text, amber and dark red badges stay badges. An artifact link shows its title (the link text, the bold label before it, else the text of its line) instead of "Artifact". With the mouse over a row only the bracket under it turns bold; with the arrows the whole row is the unit. A line of links is marked by the mouse, not walked by the arrows.
+- **The README follows a source from the command to your answer.** A short section with a diagram: source, watcher, coordinator, "Waiting for you", you.
+
 ## 1.10.0
 
 - **`jh sync` writes the ask rules the merge guard left behind.** A project sync adds `permissions.ask` rules for `gh run rerun` and the `gh api` writes that merge, write a file, dispatch or rerun a workflow, or move a ref; it records them in the lock, removes one only when the kit drops it and only if a kit shipped it, and leaves your own rules alone. Claude Code applies a matching ask rule even when a hook answers `allow`.

package/README.md

@@ -71,6 +71,21 @@ Install with one command, run `/jh-start` in a repository, and it offers your fi
 
 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. → [INSTALL.md](https://unpkg.com/jackherd/INSTALL.md)
 
+## Follow anything outside GitHub
+
+`/jh-follow` turns a ticket, an error log or a status page into something Jack acts on. It writes the source to `watch.sources` after a dry run and your yes; from then on a change takes this path:
+
+```mermaid
+flowchart LR
+  source["Source<br/>ticket, error log, status page"] -->|"new or changed entry"| watcher["jh watch"]
+  watcher -->|"=== source … report"| coordinator["Jack"]
+  coordinator -->|"board row, origin = source"| waiting["Waiting for you<br/>Error log · Checkout: …"]
+  waiting -->|"[ask]"| coordinator
+  coordinator -->|"asks you, then a lane works it"| you["You"]
+```
+
+The herd lists each source that is no ticket in a `Sources` block (when it ran, since when it fails, its newest report, a click opens it), and a row that came from a source starts with its `label`. Details and every field: [recipes](https://unpkg.com/jackherd/recipes/sources.md).
+
 ## In detail
 
 <details>
@@ -175,7 +190,7 @@ On top, **Waiting for you** lists what needs your answer: a file or Artifact sen
 ────────────────────────────────────────────────────────────────────────────────
 · no agent (1)  docs-site 1/3
 ────────────────────────────────────────────────────────────────────────────────
-↑↓ select  →← open  a ticked tasks  s html  q quit  ? help
+↑↓ select  →← open  a/click ticked tasks  s html  q quit  ? help
 ```
 
 </details>
@@ -191,7 +206,7 @@ On top, **Waiting for you** lists what needs your answer: a file or Artifact sen
 | `jh check` | types, lint and tests of what you touched, plus the plan and board checks (`--skip-slow`, `--parallel <plan>`) |
 | `jh herd` | the live view (`--once`, `--lane <name>`) |
 | `jh watch` | the watcher Jack runs |
-| `jh lane prompt <lane>` | writes a lane's first prompt from its board row and its plan (`--out`, `--handover`) |
+| `jh lane prompt <lane>` | writes a lane's first prompt from its board row and its plan (`--out`, `--handover`); your additions below the marker line at its end stay |
 | `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. Claude Code asks before each call |
 | `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) |

package/dist/{chunk-5MQBCUQ5.js → chunk-RMMXD4G5.js}

@@ -40,15 +40,21 @@ var APPOINTMENT_VOCABULARY = {
     heading: "Termine",
     columns: { when: "Wann", action: "Aktion", origin: "Herkunft", status: "Stand" },
     statusAlso: ["Status"],
-    open: ["offen"]
+    open: ["offen"],
+    grooming: "board-pflege"
   },
   [PLAN_LANGUAGE.en]: {
     heading: "Appointments",
     columns: { when: "When", action: "Action", origin: "Origin", status: "Status" },
     statusAlso: [],
-    open: ["open"]
+    open: ["open"],
+    grooming: "board grooming"
   }
 };
+var NEXT_VOCABULARY = {
+  [PLAN_LANGUAGE.de]: { heading: "Als N\xE4chstes" },
+  [PLAN_LANGUAGE.en]: { heading: "Next" }
+};
 var WAITING_VOCABULARY = {
   [PLAN_LANGUAGE.de]: {
     heading: "Wartet auf dich",
@@ -164,6 +170,7 @@ export {
   LANE_PROMPT_OPENING,
   APPROVAL_TEXTS,
   APPOINTMENT_VOCABULARY,
+  NEXT_VOCABULARY,
   WAITING_VOCABULARY,
   isPlanLanguage,
   PLAN_STATUS,

package/dist/config.d.ts

@@ -34,11 +34,22 @@ declare const sourceSchema: z.ZodObject<{
         body: z.ZodOptional<z.ZodString>;
         author: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodString>;
+        count: z.ZodOptional<z.ZodString>;
     }, z.core.$catchall<z.ZodString>>;
     ignoreAuthors: z.ZodDefault<z.ZodArray<z.ZodString>>;
     reportLimit: z.ZodDefault<z.ZodNumber>;
+    label: z.ZodOptional<z.ZodString>;
     lane: z.ZodOptional<z.ZodString>;
     ticket: z.ZodOptional<z.ZodBoolean>;
+    tone: z.ZodOptional<z.ZodEnum<{
+        amber: "amber";
+        teal: "teal";
+        grey: "grey";
+        red: "red";
+        green: "green";
+        blue: "blue";
+        magenta: "magenta";
+    }>>;
     reportOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 declare const jackherdConfigSchema: z.ZodObject<{
@@ -110,6 +121,44 @@ declare const jackherdConfigSchema: z.ZodObject<{
                 alertTokens: z.ZodDefault<z.ZodNumber>;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
+        tones: z.ZodPrefault<z.ZodObject<{
+            waiting: z.ZodDefault<z.ZodEnum<{
+                amber: "amber";
+                teal: "teal";
+                grey: "grey";
+                red: "red";
+                green: "green";
+                blue: "blue";
+                magenta: "magenta";
+            }>>;
+            new: z.ZodDefault<z.ZodEnum<{
+                amber: "amber";
+                teal: "teal";
+                grey: "grey";
+                red: "red";
+                green: "green";
+                blue: "blue";
+                magenta: "magenta";
+            }>>;
+            running: z.ZodDefault<z.ZodEnum<{
+                amber: "amber";
+                teal: "teal";
+                grey: "grey";
+                red: "red";
+                green: "green";
+                blue: "blue";
+                magenta: "magenta";
+            }>>;
+            resting: z.ZodDefault<z.ZodEnum<{
+                amber: "amber";
+                teal: "teal";
+                grey: "grey";
+                red: "red";
+                green: "green";
+                blue: "blue";
+                magenta: "magenta";
+            }>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     watch: z.ZodPrefault<z.ZodObject<{
         deploy: z.ZodOptional<z.ZodObject<{
@@ -149,11 +198,22 @@ declare const jackherdConfigSchema: z.ZodObject<{
                 body: z.ZodOptional<z.ZodString>;
                 author: z.ZodOptional<z.ZodString>;
                 status: z.ZodOptional<z.ZodString>;
+                count: z.ZodOptional<z.ZodString>;
             }, z.core.$catchall<z.ZodString>>;
             ignoreAuthors: z.ZodDefault<z.ZodArray<z.ZodString>>;
             reportLimit: z.ZodDefault<z.ZodNumber>;
+            label: z.ZodOptional<z.ZodString>;
             lane: z.ZodOptional<z.ZodString>;
             ticket: z.ZodOptional<z.ZodBoolean>;
+            tone: z.ZodOptional<z.ZodEnum<{
+                amber: "amber";
+                teal: "teal";
+                grey: "grey";
+                red: "red";
+                green: "green";
+                blue: "blue";
+                magenta: "magenta";
+            }>>;
             reportOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;

package/dist/config.js

@@ -1,7 +1,7 @@
 import {
   PLAN_LANGUAGE,
   RESPONSE_ADDRESS
-} from "./chunk-5MQBCUQ5.js";
+} from "./chunk-RMMXD4G5.js";
 
 // src/config/json-schema.ts
 import { z as z3 } from "zod";
@@ -164,7 +164,8 @@ var SOURCE_FIELD = {
   url: "url",
   body: "body",
   author: "author",
-  status: "status"
+  status: "status",
+  count: "count"
 };
 var CONTENT_FIELDS = [SOURCE_FIELD.title, SOURCE_FIELD.author, SOURCE_FIELD.body, SOURCE_FIELD.url];
 
@@ -274,6 +275,25 @@ import { isAbsolute } from "path";
 var segmentsOf = (path) => path.split(/[\\/]/).filter((segment) => segment !== "" && segment !== ".");
 var isRepositoryDirectory = (value) => !isAbsolute(value) && segmentsOf(value).length > 0 && !segmentsOf(value).includes("..");
 
+// src/config/tones.ts
+var TONE = {
+  amber: "amber",
+  teal: "teal",
+  grey: "grey",
+  red: "red",
+  green: "green",
+  blue: "blue",
+  magenta: "magenta"
+};
+var TONE_NAMES = Object.values(TONE);
+var TONE_ROLE = { waiting: "waiting", new: "new", running: "running", resting: "resting" };
+var DEFAULT_TONES = {
+  [TONE_ROLE.waiting]: TONE.amber,
+  [TONE_ROLE.new]: TONE.amber,
+  [TONE_ROLE.running]: TONE.teal,
+  [TONE_ROLE.resting]: TONE.grey
+};
+
 // src/config/schema.ts
 var TERMINAL_ADAPTER = { none: "none", herdr: "herdr" };
 var MODEL_ROLE = {
@@ -387,11 +407,14 @@ var sourceMapSchema = z2.object({
   [SOURCE_FIELD.body]: sourcePath.optional(),
   [SOURCE_FIELD.author]: sourcePath.optional(),
   /** A ticket source's status, shown on its badge in the herd; also a field `reportOn` can name. */
-  [SOURCE_FIELD.status]: sourcePath.optional()
+  [SOURCE_FIELD.status]: sourcePath.optional(),
+  /** How often the entry happened (an error count), shown as `113×` beside the entry in the herd's `Sources` block. */
+  [SOURCE_FIELD.count]: sourcePath.optional()
 }).catchall(sourcePath).refine((map) => Object.keys(map).every((field) => SOURCE_FIELD_NAME.test(field)), {
   message: "a map field is a letter, then letters, digits and `_`"
 });
 var canChange = ({ map, reportOn }) => map.updatedAt !== void 0 || CONTENT_FIELDS.some((field) => map[field] !== void 0) || reportOn !== void 0;
+var toneName = z2.enum(TONE_NAMES);
 var sourceSchema = z2.strictObject({
   /** Printed in every report of the source and the key of its saved state. */
   name: z2.string().regex(/^[A-Za-z0-9][\w.-]*$/, "letters, digits, `_`, `.` and `-`"),
@@ -406,6 +429,8 @@ var sourceSchema = z2.strictObject({
   ignoreAuthors: z2.array(z2.string().min(1)).default([]),
   /** The most new or changed entries one report shows of this source; the rest is one line `+<n> more`. */
   reportLimit: z2.number().int().min(1).default(5),
+  /** Shown before a row of "Waiting for you" that came from this source (`Error log · Checkout: …`); without it the source's name. */
+  label: z2.string().min(1).max(40).regex(/^[^\r\n]+$/, "one line").optional(),
   /** The lane the source's reports name. */
   lane: z2.string().min(1).optional(),
   /**
@@ -413,6 +438,8 @@ var sourceSchema = z2.strictObject({
    * the lane above or the lane whose board row or plan names its id.
    */
   ticket: z2.boolean().optional(),
+  /** The tone of the source's mark in the herd's `Sources` block while its newest report is new; without it the tone of the role `new`. */
+  tone: toneName.optional(),
   /**
    * The mapped fields whose change reports, with the old and the new value, in place of the content of `title`,
    * `author`, `body` and `url`; without it a change of that content reports.
@@ -512,6 +539,12 @@ var hintsSchema = z2.strictObject({
   taskSignal: z2.boolean().default(true)
 });
 var DEFAULT_TASK_SIGNAL_MINUTES = 10;
+var tonesSchema = z2.strictObject({
+  waiting: toneName.default(DEFAULT_TONES.waiting),
+  new: toneName.default(DEFAULT_TONES.new),
+  running: toneName.default(DEFAULT_TONES.running),
+  resting: toneName.default(DEFAULT_TONES.resting)
+});
 var contextSchema = z2.strictObject({
   /** Tokens in a lane's context from which its fill shows yellow and `/implement` offers a new chat. */
   warnTokens: tokenCount.default(25e4),
@@ -581,7 +614,9 @@ var jackherdConfigSchema = z2.strictObject({
         icon: z2.string().min(1)
       })
     ).default(DEFAULT_LINK_KINDS.map((kind) => ({ ...kind }))),
-    context: contextSchema.prefault({})
+    context: contextSchema.prefault({}),
+    /** The colour of each role in the herd, by name: what waits for you, what is new, what runs, what rests. */
+    tones: tonesSchema.prefault({})
   }).prefault({}),
   /**
    * Read by `jh watch`; without `deploy` it reports no deploy runs. `feedback` is on unless set to `false`:

package/dist/plan-format.d.ts

@@ -64,6 +64,12 @@ declare const APPOINTMENT_VOCABULARY: Record<PlanLanguage, {
     /** Further header names that count as the status column. */
     statusAlso: readonly string[];
     open: readonly string[];
+    /** The lower-case word an action starts with when it is the weekly board grooming, which the herd's header counts from. */
+    grooming: string;
+}>;
+/** The heading of the board section of what the coordinator does next, a numbered list of at most three lines. */
+declare const NEXT_VOCABULARY: Record<PlanLanguage, {
+    heading: string;
 }>;
 /**
  * The board section of what waits on the user's answer (a sent preview, an open question, a report to accept): its
@@ -568,4 +574,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, type ChecklistItem, type ColumnModel, type DeferredItem, type DriftFinding, LANE_PROMPT_OPENING, LANGUAGE_NAME, type LaneProgress, type LongPhaseTitle, type MergedPhaseWithOpenBoxes, type MisplacedDeferral, PHASE_CELL_LIMIT, PHASE_ID_PREFIX, PHASE_TITLE_LIMIT, PLAN_LANGUAGE, PLAN_STATUS, PLAN_VOCABULARY, PROSE_REASON, type PhaseDependency, type PhaseHeading, type PhaseProgress, type PhaseSchedule, type PhaseTally, type PhaseWithoutGate, type PhaseWithoutRow, type PlanHeader, type PlanLanguage, type PlanPhase, type PlanStatus, type PlanStep, type PlanVocabulary, type PlansByHref, type ProseReason, 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, 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, parallelGroups, parallelGroupsOfPlan, parseDependencyTable, parsePlanPhases, parseSprintLanes, phaseHeading, phaseHeadingPattern, phaseHeadings, phaseIdsOfCell, phaseIdsOfPlan, phaseLabel, phaseLabels, phaseProgress, phaseWaves, phasesText, phasesWithoutDependencyRow, readPhaseDependencies, readPlanHeader, readSprintDocument, resolvePlanPath, sectionHeading, shortNameFindings, shortTitle, sprintTitleOf, sumPhases, tallyPhases, wavesOfPlan, withoutRepeats };
+export { ADDRESS_FORM, APPOINTMENT_VOCABULARY, APPROVAL_TEXTS, type ChecklistItem, type ColumnModel, type DeferredItem, type DriftFinding, LANE_PROMPT_OPENING, LANGUAGE_NAME, type LaneProgress, type LongPhaseTitle, type MergedPhaseWithOpenBoxes, type MisplacedDeferral, NEXT_VOCABULARY, PHASE_CELL_LIMIT, PHASE_ID_PREFIX, PHASE_TITLE_LIMIT, PLAN_LANGUAGE, PLAN_STATUS, PLAN_VOCABULARY, PROSE_REASON, type PhaseDependency, type PhaseHeading, type PhaseProgress, type PhaseSchedule, type PhaseTally, type PhaseWithoutGate, type PhaseWithoutRow, type PlanHeader, type PlanLanguage, type PlanPhase, type PlanStatus, type PlanStep, type PlanVocabulary, type PlansByHref, type ProseReason, 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, 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, parallelGroups, parallelGroupsOfPlan, parseDependencyTable, parsePlanPhases, parseSprintLanes, phaseHeading, phaseHeadingPattern, phaseHeadings, phaseIdsOfCell, phaseIdsOfPlan, phaseLabel, phaseLabels, phaseProgress, phaseWaves, phasesText, phasesWithoutDependencyRow, readPhaseDependencies, readPlanHeader, readSprintDocument, resolvePlanPath, sectionHeading, shortNameFindings, shortTitle, sprintTitleOf, sumPhases, tallyPhases, wavesOfPlan, withoutRepeats };

package/dist/plan-format.js

@@ -4,6 +4,7 @@ import {
   APPROVAL_TEXTS,
   LANE_PROMPT_OPENING,
   LANGUAGE_NAME,
+  NEXT_VOCABULARY,
   PLAN_LANGUAGE,
   PLAN_STATUS,
   PLAN_VOCABULARY,
@@ -15,7 +16,7 @@ import {
   isPlanLanguage,
   phaseHeading,
   sectionHeading
-} from "./chunk-5MQBCUQ5.js";
+} from "./chunk-RMMXD4G5.js";
 
 // src/plan-format/lanes.ts
 import { posix } from "path";
@@ -499,7 +500,7 @@ var dependsOf = (cell, language) => {
   return { after, external };
 };
 var pathOf = (entry) => {
-  if (/\s/.test(entry)) return null;
+  if (/\s/.test(entry) || entry.includes("[]")) return null;
   const glob = entry.search(GLOB_CHARACTER);
   const literal = glob === -1 ? entry : entry.slice(0, Math.max(entry.lastIndexOf("/", glob), 0));
   const path = literal.replace(/^\.\//, "").replace(/\/+$/, "");
@@ -902,6 +903,7 @@ export {
   APPROVAL_TEXTS,
   LANE_PROMPT_OPENING,
   LANGUAGE_NAME,
+  NEXT_VOCABULARY,
   PHASE_CELL_LIMIT,
   PHASE_ID_PREFIX,
   PHASE_TITLE_LIMIT,

package/herdr-plugin/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "crossdelta.jackherd"
 name = "jackherd"
-version = "1.10.0"
+version = "1.11.0"
 min_herdr_version = "0.8.2"
 description = "Show the herd, the state of a board's lanes, in a herdr pane"
 platforms = ["linux", "macos"]

package/install.sh

@@ -9,7 +9,7 @@ set -eu
 
 # The default is the version this file ships with. The release bump changes it together with
 # package.json; install.test.ts fails while the two differ. Overridable, but only by a plain release.
-JACKHERD_VERSION="${JACKHERD_VERSION:-1.10.0}"
+JACKHERD_VERSION="${JACKHERD_VERSION:-1.11.0}"
 
 JACKHERD_PACKAGE='jackherd'
 # Test seam: the terminal the wizard asks its questions on.

package/kit/hooks/hooks/open-question/run.ts

@@ -28,7 +28,8 @@ export const relevantLines = (text: string): string => {
  * Records the questions of the session's dialogs that ended without an answer, and closes the open records of every
  * session that a dialog in this transcript has answered since. The whole transcript is read, not the last turn: a
  * rejected dialog ends its turn without a Stop hook, so it is found at the end of the next turn. Claude Code's hook
- * input: `cwd`, `session_id`, `transcript_path`. Writes nothing on any failure.
+ * input: `cwd`, `session_id`, `transcript_path`. A question whose text has an open record already adds none, so asking
+ * it again and putting it off again leaves one. Writes nothing on any failure.
  */
 export const runOpenQuestion = (input: unknown, dependencies: OpenQuestionDependencies): void => {
   try {
@@ -44,8 +45,12 @@ export const runOpenQuestion = (input: unknown, dependencies: OpenQuestionDepend
       if (answer) dependencies.writeRecord(main, { ...record, closedAt: answer.answeredAt })
     }
     const known = new Set(stored.map(({ id }) => id))
-    for (const record of openQuestionsOf(entries, { cwd, session, answered, idOf: dependencies.idOf }))
-      if (!known.has(record.id)) dependencies.writeRecord(main, record)
+    const openTexts = new Set(stored.filter(({ closedAt }) => closedAt === null).map(({ question }) => question))
+    for (const record of openQuestionsOf(entries, { cwd, session, answered, idOf: dependencies.idOf })) {
+      if (known.has(record.id) || openTexts.has(record.question)) continue
+      openTexts.add(record.question)
+      dependencies.writeRecord(main, record)
+    }
   } catch {
     // A failed record is no record; the herd shows no question.
   }

package/kit/rules/rules/kit/pull-requests.md

@@ -42,6 +42,8 @@ Add a fenced ` ```mermaid ` block **when it removes reader effort**:
 
 Keep each diagram to one idea; two small diagrams beat one dense one. Small or single-file PRs need none.
 
+Write edge labels as `-->|"label"|` (`-- text -->` breaks on a `--` in it); `jh mermaid <body file>` must exit 0 before `gh pr create` or `gh pr edit`.
+
 ## Review order (large PRs)
 
 When a PR spans many files, add a short **suggested review order** — **pure/domain logic first, adapters next, UI and wiring last**. A `| # | Area | Start here | Why first |` table works well.

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

@@ -15,8 +15,8 @@ You add one entry to `watch.sources`, so that `jh watch` reports a new or change
 - **Service:** the services the recipe index lists, and "another command that prints JSON".
 - **What to follow:** the item the argument names (its comments, recommended) or a query over several items.
 - **Lane:** the lane the reports name, from the board's lanes table, or none.
-- **Ticket:** whether the entries are tickets (`ticket: true`, recommended for an issue tracker or a project board), which the herd shows as a badge beside the plan of their lane: the lane above, or the lane whose name, board row or plan names the ticket's id. A source of comments or messages is no ticket. The path of the status you find yourself in step 3.
-- **What reports:** a change of what the user reads (title, body, the latest comment; recommended), or a change of named fields such as a status (`reportOn` with those fields, mapped in `map`).
+- **Ticket:** whether the entries are tickets (`ticket: true`, recommended for an issue tracker or a project board), which the herd shows as a badge beside the plan of their lane: the lane above, or the lane whose name, board row or plan names the ticket's id. A source of comments or messages is no ticket; it shows in the herd's `Sources` block instead (a click opens the entry at `map.url`). The path of the status you find yourself in step 3.
+- **Tone:** for a non-ticket source, the colour of its `Sources` mark while its report is new (`tone`: amber, teal, grey, red, green, blue, magenta); recommended: no `tone`.- **What reports:** a change of what the user reads (title, body, the latest comment; recommended), or a change of named fields such as a status (`reportOn` with those fields, mapped in `map`).
 - **Own changes:** ignore the user's own account on that service (`ignoreAuthors`, needs an author in the map), or report everything.
 
 ## 2. Check, read only
@@ -30,7 +30,7 @@ Anything missing goes to the user as the command to run themselves (`! <command>
 
 Before filling, read the help of the installed CLI version for every command the recipe calls (`acli jira workitem search --help` and `workitem view --help`, `gh issue list --help`) and confirm that the fields and options the entry needs exist there. Read the provider's web documentation only when the help leaves it open or no recipe fits. A recipe is a starting point; the installed version decides.
 
-Fill the recipe with the item or query and the answers from step 1: a `name` of letters, digits, `.`, `_` and `-` that says what is followed, `lane`, `ignoreAuthors` and `ticket` where chosen. For a ticket source, find the path of the status in the output (from the CLI's help, or the dry run with `--raw`) and set it as `map.status`; the entry you show for approval in step 4 carries it, and without a status in the output the entry has none and the badge shows only the key. A recipe that needs a script (a token from the environment, or one call per item) gets TypeScript run by Bun: write it, from the recipe's script under `recipes/sources/`, to the scratchpad first as `<name>.ts`, never into the repository before step 4, and let the entry's `command` be `["bun", "scripts/sources/<name>.ts"]`. Script and direct command follow the index's **Rules every recipe follows**.
+Fill the recipe with the item or query and the answers from step 1: a `name` of letters, digits, `.`, `_` and `-` that says what is followed, `lane`, `ignoreAuthors`, `ticket` and `tone` where chosen, and a short `label` (e.g. `Error log · Checkout`; it prefixes the source's `Waiting for you` rows). For a ticket source, find the path of the status in the output (from the CLI's help, or the dry run with `--raw`) and set it as `map.status`; the entry you show for approval in step 4 carries it, and without a status in the output the entry has none and the badge shows only the key. A recipe that needs a script (a token from the environment, or one call per item) gets TypeScript run by Bun: write it, from the recipe's script under `recipes/sources/`, to the scratchpad first as `<name>.ts`, never into the repository before step 4, and let the entry's `command` be `["bun", "scripts/sources/<name>.ts"]`. Script and direct command follow the index's **Rules every recipe follows**.
 
 Write the entry as one JSON object to a draft file in the scratchpad and run, from the main checkout:
 

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

@@ -67,7 +67,7 @@ Each file under `references/` is read when its trigger fires: the step or the ev
 `jh lane prompt <lane> [--board <board>]` writes the lane prompt from the lane's board row and its plan, in
 the plan's language, to `.claude/handover/<lane>-prompt.md` and prints the path. It opens with a first line
 that names the lane, which the hooks and the project's rules read: keep that line as it is. Before you send
-it, add to the file with `Edit` the open questions that touch the lane and what the project
+it, add to the file with `Edit`, below the marker line at its end (it stays through every new writing), the open questions that touch the lane and what the project
 supplement adds to the lane prompt. Never paste the rules of this skill into a lane prompt. The lane asks you in text blocks at the end of its turn; answer them with
 `herdr agent prompt` (§ 2 step 8).
 
@@ -290,10 +290,18 @@ watcher reports an open row once when it falls due (`due`, above); an empty stat
 and a reworded or moved row is a new appointment and reports again. Close a reported row through its
 status cell.
 
+**Board grooming** is an appointment of its own, a row in that section whose action starts with
+`Board-Pflege` (`Board grooming`); a board without one gets it, due a week from now. When it reports:
+check that the open lane rows still serve the board's goal (a mismatch joins the bundled question), rewrite the
+board's `Als Nächstes` (`Next`) section (three lines at most, each with a date), clear finished lane
+rows, ask for outdated plans in one bundled question, then set its `When` a week after now and leave its status
+empty: this is the one appointment that is moved, not closed. The herd
+counts `groomed <n>d ago` from it and turns it amber at eight days.
+
 **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 in the same turn you send it, 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**. It survives a hand-over, which a
+(`Seit | Punkt | Herkunft | Stand`) with the time as in **An agreed time**; for a source's report the origin is the source's name, and the herd prefixes the row with its label. It survives a hand-over, which a
 message in this chat does not. Close a row in its status cell in the turn the user's answer arrives (also a
 "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 (the kit hook `sent-file` records each): close them after the answer with

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jackherd",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "keywords": [
     "claude-code",
     "coding-agents",

package/recipes/sources.md

@@ -60,6 +60,10 @@ A run that ends with an exit code other than 0, runs past 30 seconds (then its w
 
 **Show a ticket beside its plan.** `"ticket": true` marks a source's entries as tickets. The herd then shows each one as a badge in the 📎 line of its lane's plan, right after `📄 Plan`: `📡 T-123 · In Progress`, linked to the ticket. A ticket belongs to the source's `lane`, and also to any lane whose board row, name or plan names its id as a whole word (`T-12` is not found in `T-123`); so one source listing all your open tickets works without `lane`. `map.status` is the status the badge shows; without it the badge shows only the key. A ticket whose last reported change is less than a day old is amber, and a folded lane then shows `📡 <n>` in amber before its bar, linked to the first new ticket. A lane shows at most three tickets, new ones first, then `+<n>`; a link chip of the plan with the same URL gives way to the badge. For this the saved state keeps, of a marked source only, each entry of its last successful run with its URL, its status (stored like a `reportOn` value) and the time its last change was reported. The badges come from the watcher's state like the pull request badges: without a running watcher or with a state older than three minutes there are none, and the header says `watcher off` or `state 4 min old`, also without a pull request. The [GitHub Projects recipe](#user-content-recipes) is a ticket source with a status.
 
+**Show a source in the herd.** A source without `ticket` appears in the herd's `Sources` block, one row each: its name, when it last ran (`ran 12 min ago`), since when it fails (`failing since 3 h ago`, mark red) and its newest report (mark amber while that report is under a day old). A source with several entries is one folded row; a click opens its entries (up to five, then `+<n> more`), each with its title, `map.count` as `113×` and the time of its last change. A click on an entry opens its `url` (the watcher keeps it only as a checked `https:` URL of at most 200 characters, so map a short link), `[ask]` asks the coordinator to look at that entry. An entry that an open row of "Waiting for you" already asks about (the row's `Origin` names the source and its text the title) is dim and says `↑ asked`; the row is amber only for a new entry nobody asked about. The watcher keeps the last 20 entries of such a source. `tone` (amber, teal, grey, red, green, blue or magenta) sets the mark's colour while the report is new, instead of the tone of the role `new`; the roles `waiting`, `new`, `running` and `resting` take their tones from `plans.tones` in the config (defaults: amber, amber, teal, grey).
+
+**Name a source in "Waiting for you".** A row of the board's waiting section whose `Origin` cell is the name of a source (case ignored) shows `<label>: <row>` in the herd; `label` (one line, at most 40 characters) is optional, without it the source's name stands before the row. `/jh-follow` proposes a short label when it writes the entry.
+
 **How you hear about it.** The report goes to the coordinator, as a `=== source …` event of its watcher. It passes you one line with the entry, its gist and the link. A decision inside it, such as a product owner's answer, it takes over only after you confirmed it, since the text comes from outside. You hear of it only while the coordinator's session and its watcher run; what happened in between is reported at the next start. There is no desktop notification of its own: you get the one herdr shows for any lane that needs you. What a source reports is a change in the mapped content fields (`title`, `author`, `body`, `url`), or with `reportOn` a change of the fields it names, such as a status.
 
 **Try a source before the watcher runs it.** `jh watch source <name> --dry-run` runs a configured source once; a draft not yet in the config comes as a file (`jh watch source draft.json --dry-run`, one source object) or on stdin (`-`). It lists the entries (`<id> · <author> · <title>`), says that the watcher's first run of the source is a baseline and reports nothing, and shows one entry as a later report would print it; it neither reads nor changes the watcher's state. A field of `map` that is empty in every entry is named with its path (`map.updatedAt: in 23 of 23 entries empty (.fields.updated)`), read from the raw output, so a run that failed on a missing `id` or `updatedAt` names it too; the dry run then ends with exit code 1, as for a failed run, and `/jh-follow` does not write the source. Without entries it says `0 entries: map not checked`. `--raw` adds the command's output, for finding the paths of `items` and `map`:

package/schemas/jackherd.schema.json

@@ -297,6 +297,65 @@
             }
           },
           "additionalProperties": false
+        },
+        "tones": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "waiting": {
+              "default": "amber",
+              "type": "string",
+              "enum": [
+                "amber",
+                "teal",
+                "grey",
+                "red",
+                "green",
+                "blue",
+                "magenta"
+              ]
+            },
+            "new": {
+              "default": "amber",
+              "type": "string",
+              "enum": [
+                "amber",
+                "teal",
+                "grey",
+                "red",
+                "green",
+                "blue",
+                "magenta"
+              ]
+            },
+            "running": {
+              "default": "teal",
+              "type": "string",
+              "enum": [
+                "amber",
+                "teal",
+                "grey",
+                "red",
+                "green",
+                "blue",
+                "magenta"
+              ]
+            },
+            "resting": {
+              "default": "grey",
+              "type": "string",
+              "enum": [
+                "amber",
+                "teal",
+                "grey",
+                "red",
+                "green",
+                "blue",
+                "magenta"
+              ]
+            }
+          },
+          "additionalProperties": false
         }
       },
       "additionalProperties": false
@@ -483,6 +542,9 @@
                   },
                   "status": {
                     "type": "string"
+                  },
+                  "count": {
+                    "type": "string"
                   }
                 },
                 "required": [
@@ -506,6 +568,12 @@
                 "minimum": 1,
                 "maximum": 9007199254740991
               },
+              "label": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 40,
+                "pattern": "^[^\\r\\n]+$"
+              },
               "lane": {
                 "type": "string",
                 "minLength": 1
@@ -513,6 +581,18 @@
               "ticket": {
                 "type": "boolean"
               },
+              "tone": {
+                "type": "string",
+                "enum": [
+                  "amber",
+                  "teal",
+                  "grey",
+                  "red",
+                  "green",
+                  "blue",
+                  "magenta"
+                ]
+              },
               "reportOn": {
                 "minItems": 1,
                 "maxItems": 10,

package/src/cli.ts

@@ -25,6 +25,7 @@ export const COMMANDS: CommandTable = {
   init: () => import('./sync/init-command'),
   [HERD_COMMAND.alias]: () => import('./plans/command'),
   lane: () => import('./lane/command'),
+  mermaid: () => import('./mermaid/command'),
   preview: () => import('./preview/command'),
   settled: () => import('./settled/command'),
   sync: () => import('./sync/command'),