jackherd 1.6.1 → 1.7.0

package/dist/config.js

@@ -1,7 +1,7 @@
 import {
   PLAN_LANGUAGE,
   RESPONSE_ADDRESS
-} from "./chunk-QJSXHHQ3.js";
+} from "./chunk-OBUWTQ6Z.js";
 
 // src/config/json-schema.ts
 import { z as z3 } from "zod";
@@ -157,8 +157,10 @@ var SOURCE_FIELD = {
   title: "title",
   url: "url",
   body: "body",
-  author: "author"
+  author: "author",
+  status: "status"
 };
+var CONTENT_FIELDS = [SOURCE_FIELD.title, SOURCE_FIELD.author, SOURCE_FIELD.body, SOURCE_FIELD.url];
 
 // src/watch/source-path.ts
 var ROOT_PATH = ".";
@@ -176,6 +178,10 @@ var pathSteps = (path) => {
 };
 var isSourcePath = (path) => pathSteps(path) !== null;
 
+// src/watch/watch-defaults.ts
+var CLEAN_REVIEW_TEXT = "## Code review\n\nNo issues found. Checked for bugs and CLAUDE.md compliance.";
+var BUN_FAILED_TEST_PATTERN = "^\\(fail\\) (.+?)(?: \\[[\\d.]+m?s\\])?$";
+
 // src/config/link-kinds.ts
 var DEFAULT_LINK_KINDS = [
   { pattern: "^https://github\\.com/[^/]+/[^/]+/(pull|issues)/\\d+", label: "GitHub", icon: "\u2442" },
@@ -191,6 +197,65 @@ var isRegularExpression = (source) => {
   }
 };
 
+// src/config/nested-quantifier.ts
+var GROUP_PREFIX = /^\?(?::|=|!|<=|<!|<[^>]+>)/;
+var BRACES = /^\{(\d+)(?:(,)(\d*))?\}/;
+var repeatingLengthAt = (pattern, index) => {
+  if (pattern[index] === "*" || pattern[index] === "+") return 1;
+  const braces = pattern.slice(index).match(BRACES);
+  const [text, , comma, max] = braces ?? [];
+  return text !== void 0 && comma && (max === "" || Number(max) > 1) ? text.length : 0;
+};
+var classEnd = (pattern, start) => {
+  let index = start + 1;
+  while (index < pattern.length && pattern[index] !== "]") index += pattern[index] === "\\" ? 2 : 1;
+  return index;
+};
+var overlapsAnother = (branches) => branches.some(
+  (branch, index) => branches.some((other, otherIndex) => index !== otherIndex && other.startsWith(branch))
+);
+var NESTED = -1;
+var appendTo = (group, text) => {
+  group.branches[group.branches.length - 1] += text;
+};
+var prefixLengthAt = (pattern, index) => pattern.slice(index + 1).match(GROUP_PREFIX)?.[0].length ?? 0;
+var closeGroup = (pattern, index, groups) => {
+  const closed = groups.pop();
+  const repeated = repeatingLengthAt(pattern, index + 1) > 0;
+  if (repeated && (closed.repeats || overlapsAnother(closed.branches))) return NESTED;
+  groups[groups.length - 1].repeats ||= closed.repeats;
+  return index + 1;
+};
+var stepAt = (pattern, index, groups) => {
+  const top = groups[groups.length - 1];
+  const char = pattern[index];
+  const literalEnd = char === "\\" ? index + 2 : classEnd(pattern, index) + 1;
+  const quantifierLength = repeatingLengthAt(pattern, index);
+  if (char === "\\" || char === "[") appendTo(top, pattern.slice(index, literalEnd));
+  else if (char === "(") groups.push({ repeats: false, branches: [""] });
+  else if (char === ")" && groups.length > 1) return closeGroup(pattern, index, groups);
+  else if (char === "|") top.branches.push("");
+  else if (quantifierLength > 0) top.repeats = true;
+  else appendTo(top, char);
+  if (char === "\\" || char === "[") return literalEnd;
+  if (char === "(") return index + 1 + prefixLengthAt(pattern, index);
+  return index + Math.max(quantifierLength, 1);
+};
+var hasNestedQuantifier = (pattern) => {
+  const groups = [{ repeats: false, branches: [""] }];
+  let index = 0;
+  while (index < pattern.length) {
+    index = stepAt(pattern, index, groups);
+    if (index === NESTED) return true;
+  }
+  return false;
+};
+
+// src/config/repository-directory.ts
+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/schema.ts
 var TERMINAL_ADAPTER = { none: "none", herdr: "herdr" };
 var MODEL_ROLE = {
@@ -228,7 +293,7 @@ var boardSchema = z2.strictObject({
   pattern: boardPattern.default("board-*"),
   /** The board document inside each of those directories. */
   file: boardFile.default("board.md"),
-  /** What the project calls a board: the plans view, its page and the watcher print it as written. */
+  /** What the project calls a board: the herd, its page and the watcher print it as written. */
   term: z2.string().min(1).default("board")
 });
 var deploySchema = z2.strictObject({
@@ -239,7 +304,23 @@ var deploySchema = z2.strictObject({
 });
 var feedbackSchema = z2.strictObject({
   /** GitHub logins whose feedback does not wake the coordinator, such as a status bot; case is ignored. */
-  ignore: z2.array(z2.string().min(1)).default([])
+  ignore: z2.array(z2.string().min(1)).default([]),
+  /**
+   * Texts of a bot's pull request comment that report no finding: such a comment (login ending `[bot]`, no inline
+   * comment by the same author within five minutes of it) is no feedback. Compared with whitespace collapsed; the
+   * default is the CI code review's comment for a clean run. An empty list counts every bot comment.
+   */
+  noFindingTemplates: z2.array(z2.string().min(1)).default([CLEAN_REVIEW_TEXT])
+});
+var checksSchema = z2.strictObject({
+  /**
+   * Finds a failed test in a line of a red run's log (`gh run view --log-failed`) after its job, step and timestamp
+   * prefix: the first group is the name, else the match. The default is Bun's `(fail) <name> [<duration>]`. The
+   * watcher runs it on every line of a log it does not control, so a pattern that repeats a group which repeats inside
+   * itself (`(a+)+`, `(\w*)*`, and with alternation `(a|aa)+`) is refused: a best-effort scan of the source against
+   * catastrophic backtracking, not a proof.
+   */
+  failedTestPattern: z2.string().min(1).refine(isRegularExpression, "not a valid regular expression").refine((pattern) => !hasNestedQuantifier(pattern), "a quantified group that holds a quantifier backtracks badly").default(BUN_FAILED_TEST_PATTERN)
 });
 var previewsSchema = z2.strictObject({
   /** Reads the GitHub deployments of each head commit; a successful one outside production and `deploy.environments` names its `environment_url`. */
@@ -256,17 +337,23 @@ var sourcePath = z2.string().refine(isSourcePath, "not a source path: `.`, or `.
 var SOURCE_FIELD_NAME = /^[A-Za-z][A-Za-z0-9_]*$/;
 var sourceMapSchema = z2.object({
   [SOURCE_FIELD.id]: sourcePath,
-  /** Changes whenever the entry changes; compared as text, so any stable form of a time or version works. */
-  [SOURCE_FIELD.updatedAt]: sourcePath,
+  /**
+   * Changes whenever the entry changes; compared as text, so any stable form of a time or version works. Needed
+   * only where no content field and no `reportOn` can tell a change.
+   */
+  [SOURCE_FIELD.updatedAt]: sourcePath.optional(),
   [SOURCE_FIELD.title]: sourcePath.optional(),
   /** Shown only as an `https:` URL without user name or password. */
   [SOURCE_FIELD.url]: sourcePath.optional(),
   /** The first line with text is shown. */
   [SOURCE_FIELD.body]: sourcePath.optional(),
-  [SOURCE_FIELD.author]: 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()
 }).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 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 `-`"),
@@ -283,11 +370,19 @@ var sourceSchema = z2.strictObject({
   reportLimit: z2.number().int().min(1).default(5),
   /** The lane the source's reports name. */
   lane: z2.string().min(1).optional(),
+  /**
+   * Marks the entries as tickets: the herd shows each as a badge beside the plan of the lane it belongs to,
+   * the lane above or the lane whose board row or plan names its id.
+   */
+  ticket: z2.boolean().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.
    */
   reportOn: z2.array(z2.string().min(1)).min(1).max(10).optional()
+}).refine(canChange, {
+  message: "map needs updatedAt, a content field (title, author, body, url) or reportOn",
+  path: ["map"]
 }).refine((source) => source.ignoreAuthors.length === 0 || source.map.author !== void 0, {
   message: "ignoreAuthors needs map.author",
   path: ["ignoreAuthors"]
@@ -331,6 +426,10 @@ var guardSchema = z2.strictObject({
     offer: z2.boolean().default(true),
     /** How long an answer to that question lets `gh pr merge <number>` pass without asking, counted from the answer. */
     approvalMinutes: z2.number().int().min(1).max(1440).default(180)
+  }).prefault({}),
+  approvals: z2.strictObject({
+    /** How long the approval gate hook holds a lane's call for the coordinator's dialog before it denies it; below the hook's 10 minutes. */
+    waitMinutes: z2.number().int().min(1).max(9).default(8)
   }).prefault({})
 });
 var hintsSchema = z2.strictObject({
@@ -360,7 +459,7 @@ var jackherdConfigSchema = z2.strictObject({
   board: boardSchema.prefault({}),
   /** Replaced by `board.pattern` in 0.13.0; named here only so an old config is refused with that hint. */
   sprintPattern: z2.never({ error: "sprintPattern was replaced by board.pattern (with board.file and board.term)" }).optional(),
-  worktreeDirectory: z2.string().min(1).default(claudePath(WORKTREES_DIRECTORY)),
+  worktreeDirectory: z2.string().min(1).refine(isRepositoryDirectory, "must lie below the repository root: relative, not `.`, without `..`").default(claudePath(WORKTREES_DIRECTORY)),
   baseBranch: branchName.default(DEFAULT_BASE_BRANCH),
   /**
    * Put before every skill and agent name. `jh sync --global` refuses to run without one: a personal skill
@@ -388,7 +487,7 @@ var jackherdConfigSchema = z2.strictObject({
   models: z2.record(z2.enum(Object.values(MODEL_ROLE)), modelId),
   terminal: z2.strictObject({ adapter: z2.enum(Object.values(TERMINAL_ADAPTER)).default(TERMINAL_ADAPTER.none) }).prefault({}),
   plans: z2.strictObject({
-    /** Minutes between background fetches of the base branch while `jh plans` runs; 0 turns them off. */
+    /** Minutes between background fetches of the base branch while `jh herd` runs; 0 turns them off. */
     fetchIntervalMinutes: z2.number().min(0).default(5),
     /** Links in a plan that the sprint page shows as chips; the list replaces the built-in kinds. */
     linkKinds: z2.array(
@@ -403,12 +502,14 @@ var jackherdConfigSchema = z2.strictObject({
   /**
    * Read by `jh watch`; without `deploy` it reports no deploy runs. `feedback` is on unless set to `false`:
    * it reports new feedback on the lanes' pull requests except from the account the watcher runs as and `ignore`.
+   * `checks` reads the failed tests of a red lane pull request (`failedTestPattern`), also with `feedback` off.
    * Without `previews` it reads no deploy preview; with it, one `preview` per new head commit. Each of `sources` is a
    * command whose JSON output reports `source` for a new or changed entry.
    */
   watch: z2.strictObject({
     deploy: deploySchema.optional(),
-    feedback: z2.union([z2.literal(false), feedbackSchema]).default({ ignore: [] }),
+    feedback: z2.union([z2.literal(false), feedbackSchema]).prefault({}),
+    checks: checksSchema.prefault({}),
     previews: previewsSchema.optional(),
     sources: z2.array(sourceSchema).refine(hasUniqueNames, "source names must be unique").default([])
   }).prefault({}),

package/dist/plan-format.d.ts

@@ -22,6 +22,16 @@ declare const ADDRESS_FORM: Record<PlanLanguage, Record<ResponseAddress, string>
  * a config value.
  */
 declare const SELF_MERGE_LABEL: Record<PlanLanguage, string>;
+/**
+ * The words of an approval: the two option labels of the coordinator's question about a lane's call, which the
+ * approval gate hook matches exactly, and what the hook tells the lane when it denies. Fixed per language, not config.
+ */
+declare const APPROVAL_TEXTS: Record<PlanLanguage, {
+    allow: string;
+    deny: string;
+    pending: string;
+    denied: string;
+}>;
 declare const isPlanLanguage: (value: string) => value is PlanLanguage;
 declare const PLAN_STATUS: {
     readonly done: "done";
@@ -68,8 +78,18 @@ type PlanVocabulary = {
     laneClosed: string;
     /** Words a starts-after cell begins with when the lane may start at once. */
     startsNow: readonly string[];
+    /** Opens the parenthesis by which a board row's phases cell records a user's side order in prose. */
+    sideOrderMarker: string;
     /** Words that may stand between two phases of one entry (`P1 Rule und P2 Monitor`). */
     phaseConnectors: readonly string[];
+    /** Words that open a writes cell naming another phase's set instead of listing it (`wie 15`). */
+    writesLike: readonly string[];
+    /** Words that join several phases after a `writesLike` word (`wie 15 und 16`); a comma joins them in every language. */
+    writesLikeJoiners: readonly string[];
+    /** Words a `Depends on` cell says it depends on nothing with, besides a dash. */
+    noDependency: readonly string[];
+    /** The word that opens the serial marker of a phase that ships in a release (`Release 1.7.0`); the release files stay a judgement. */
+    releaseMarker: string;
     statusWords: Record<PlanStatus, StatusWord>;
 };
 declare const PLAN_VOCABULARY: Record<PlanLanguage, PlanVocabulary>;
@@ -79,6 +99,139 @@ declare const classifyStatus: (language: PlanLanguage, statusText: string) => Pl
 declare const phaseHeading: (language: PlanLanguage, id: string, title: string) => string;
 declare const sectionHeading: (language: PlanLanguage, section: keyof PlanVocabulary["sections"]) => string;
 
+/**
+ * The longest phases cell, in characters, that still reads as a phase and its state. Longer cells in the open
+ * lanes of the real boards carry prose, which belongs in the plan.
+ */
+declare const PHASE_CELL_LIMIT = 250;
+declare const PROSE_REASON: {
+    readonly long: "long";
+    readonly sideOrder: "side-order";
+};
+type ProseReason = (typeof PROSE_REASON)[keyof typeof PROSE_REASON];
+/** A changed row of an open lane (1-based line) whose phases cell is `length` characters and carries prose. */
+type RowWithProse = {
+    line: number;
+    lane: string;
+    reason: ProseReason;
+    length: number;
+};
+/**
+ * The changed rows of open lanes whose phases cell is longer than `PHASE_CELL_LIMIT` or records a side order of the
+ * user in prose (`dazu (User …`): the board row names the phase, the side order is a task in the plan's phase.
+ * A cell that is both counts once, as a side order.
+ */
+declare const boardRowsWithProse: (markdown: string, language: PlanLanguage, previousLines: ReadonlySet<string>) => RowWithProse[];
+
+/** A checkbox of a plan. `gate` is set on the ones listed under the phase's review gate, and only on those. */
+type ChecklistItem = {
+    done: boolean;
+    text: string;
+    gate?: true;
+};
+/** An open checkbox that ends in `→ P<n>`: moved on purpose to phase `target`, its text without the marker. */
+type DeferredItem = {
+    text: string;
+    target: string;
+};
+/** An open checkbox whose phase arrow is not at the end of its line (1-based), with the form the parser reads. */
+type MisplacedDeferral = {
+    line: number;
+    target: string;
+    corrected: string;
+};
+/**
+ * `touched` is set by the phase source when the worktree's ticks differ from the base branch's. `deferred` holds
+ * the checkboxes moved to another phase; they are not among `items`, so they count neither as open nor as done.
+ */
+type PlanPhase = {
+    id: string;
+    title: string;
+    items: ChecklistItem[];
+    deferred?: DeferredItem[];
+    touched?: true;
+};
+/** A phase heading with its 1-based line, the lower-case id and the title. */
+type PhaseHeading = {
+    line: number;
+    id: string;
+    title: string;
+};
+/** The line that opens a phase's review gate: `**Review-Gate:**`, `**Review gate** (…)`. */
+declare const isReviewGateLine: (line: string) => boolean;
+/** A heading of level three or higher, which ends the section of a phase. */
+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 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.
+ */
+declare const deferralTarget: (line: string, phaseId: string) => string | null;
+/**
+ * Open checkboxes that carry `→ P<n>` somewhere other than at the end of the line. `deferralTarget` reads the arrow
+ * only there, so such a box counts as open in its own phase without a word; `jh check` refuses it. In an
+ * open checkbox the phase arrow stands only at the end, also where it would be meant as prose (`→ P2 prüfen`).
+ */
+declare const misplacedDeferrals: (markdown: string) => MisplacedDeferral[];
+/** Every phase heading of a plan, `### Phase <id>` and `## P<id> — title` alike, with its 1-based line. */
+declare const phaseHeadings: (markdown: string, language: PlanLanguage) => PhaseHeading[];
+/**
+ * Every `### Phase <id>` section, and every `## <id> — title` section, with its checkboxes. A
+ * section runs to the next heading of level three or higher, so a review-gate list or a `####`
+ * sub-heading inside the phase still counts. A phase without checkboxes of its own that points at
+ * a section (``Siehe `## Dokumentation` ``) counts that section's items, so it is done when the
+ * section is. An open checkbox ending in `→ P<n>` is kept under `deferred` and listed in phase `<n>` as open.
+ */
+declare const parsePlanPhases: (markdown: string, language: PlanLanguage) => PlanPhase[];
+
+/**
+ * A row of the dependency table. `after` holds the phases it waits for, `external` the entries that name no phase
+ * (`User: Zuruf`) or a range that cannot be expanded; `writes` are the paths of the writes cell (`''` is the whole
+ * repository), `writesLike` the phases whose sets the cell takes over (`wie 15 und 16`); `serialMarkers` are the
+ * entries of the marker cell that keep two phases apart.
+ */
+type PhaseDependency = {
+    id: string;
+    after: string[];
+    external: string[];
+    writes: string[];
+    writesLike: string[];
+    serialMarkers: string[];
+};
+/** A phase heading (1-based line) the dependency table has no row for. */
+type PhaseWithoutRow = PhaseHeading;
+/**
+ * The rows of the plan's dependency table (`### Abhängigkeiten und Parallelisierung`); null when the plan has no
+ * such table or the table lacks one of its three columns, so a plan that never had one is not asked for rows.
+ */
+declare const parseDependencyTable: (markdown: string, language: PlanLanguage) => PhaseDependency[] | null;
+/** The phase headings of a plan with a dependency table that the table has no row for; null for a plan without one. */
+declare const phasesWithoutDependencyRow: (markdown: string, language: PlanLanguage) => PhaseWithoutRow[] | null;
+/**
+ * The phases that can run side by side, as groups in table order: the first group can start now, a later one holds
+ * the ready phases that collide with an earlier group's members. A phase is offered when it is not in `doneIds`,
+ * every phase in its `Depends on` cell is, and the cell names no external gate: nothing in the plan says such a gate
+ * holds, so the phase stays out and the caller asks. Two phases share a group only when no path of one lies at or
+ * below a path of the other (a root path lies below nothing and above everything) and they share no serial marker,
+ * compared without case (a release marker does not count). A `wie N` writes cell takes the set of phase N; a phase
+ * whose set is empty, whose `wie` target is unknown, or whose `wie` chain is a cycle, cannot be shown disjoint and
+ * stays out. Whether two phases collide in content, or in the release files, is not decided here.
+ */
+declare const parallelGroups: (rows: readonly PhaseDependency[], doneIds: ReadonlySet<string>) => string[][];
+/** The phases as a report names them, side by side: `P19 ∥ P20`. */
+declare const phasesText: (phases: readonly string[]) => string;
+/** `parallelGroups` of the plan's own dependency table and ticks (a phase is done when every box is ticked); null for a plan without a table. */
+declare const parallelGroupsOfPlan: (markdown: string, language: PlanLanguage) => string[][] | null;
+
+/** The review-gate box `Dokumentation aktualisiert …` (`Documentation updated …`): a gate item starting with the documentation word. */
+declare const isDocumentationGateItem: ({ gate, text }: ChecklistItem) => boolean;
+/** The documentation gate box is the only unticked box of the phase: everything else is done. */
+declare const onlyDocumentationOpen: ({ items }: {
+    items: readonly ChecklistItem[];
+}) => boolean;
+
 type DriftFinding = {
     file: string;
     reason: string;
@@ -121,6 +274,12 @@ type SprintLane = {
     steps: PlanStep[];
     closed: boolean;
 };
+/** A row of the lanes table (1-based line) of an open lane with the text of its phases cell. */
+type OpenLaneRow = {
+    line: number;
+    lane: string;
+    phases: string;
+};
 /** Sprint tables name a phase `P4`; the sidebar title prints it the same way. */
 declare const PHASE_ID_PREFIX = "P";
 /** The phase ids a phases cell of the lanes table names, read as `parseSprintLanes` reads them. */
@@ -138,6 +297,22 @@ declare const sprintTitleOf: (markdown: string, fallback: string) => string;
 /** The repository path of a plan link, relative to the sprint document's directory. */
 declare const resolvePlanPath: (sprintDirectory: string, href: string) => string;
 
+/**
+ * A model as a board's model column names it: its words (`Opus 5.5` names `opus`; `claude-sonnet-5-5` names
+ * `claude` and `sonnet`, one of which is the family) and its version (`['5', '5']`).
+ */
+type ColumnModel = {
+    names: string[];
+    version: string[];
+};
+/** The models a model column names, in its order; a note in brackets (`(Plan)`) and a dash name none. */
+declare const columnModels: (column: string) => ColumnModel[];
+/**
+ * Whether a running model's id fits none of the models the column names, by family and version (`Opus 5.5` fits
+ * `claude-opus-5-5`, also with a date or window suffix). Knows no vendor. A column that names no model never differs.
+ */
+declare const differsFromColumn: (column: string, modelId: string) => boolean;
+
 /** Per heading that carries checkboxes or table status cells: how many are done and open. */
 type PhaseTally = {
     title: string;
@@ -153,73 +328,10 @@ type PhaseTally = {
  */
 declare const tallyPhases: (markdown: string, language: PlanLanguage) => PhaseTally[];
 
-/** A checkbox of a plan. `gate` is set on the ones listed under the phase's review gate, and only on those. */
-type ChecklistItem = {
-    done: boolean;
-    text: string;
-    gate?: true;
-};
-/** An open checkbox that ends in `→ P<n>`: moved on purpose to phase `target`, its text without the marker. */
-type DeferredItem = {
-    text: string;
-    target: string;
-};
-/** An open checkbox whose phase arrow is not at the end of its line (1-based), with the form the parser reads. */
-type MisplacedDeferral = {
-    line: number;
-    target: string;
-    corrected: string;
-};
-/**
- * `touched` is set by the phase source when the worktree's ticks differ from the base branch's. `deferred` holds
- * the checkboxes moved to another phase; they are not among `items`, so they count neither as open nor as done.
- */
-type PlanPhase = {
-    id: string;
-    title: string;
-    items: ChecklistItem[];
-    deferred?: DeferredItem[];
-    touched?: true;
-};
-/** The line that opens a phase's review gate: `**Review-Gate:**`, `**Review gate** (…)`. */
-declare const isReviewGateLine: (line: string) => boolean;
-/** A heading of level three or higher, which ends the section of a phase. */
-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 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.
- */
-declare const deferralTarget: (line: string, phaseId: string) => string | null;
-/**
- * Open checkboxes that carry `→ P<n>` somewhere other than at the end of the line. `deferralTarget` reads the arrow
- * only there, so such a box counts as open in its own phase without a word; `jh check` refuses it. In an
- * open checkbox the phase arrow stands only at the end, also where it would be meant as prose (`→ P2 prüfen`).
- */
-declare const misplacedDeferrals: (markdown: string) => MisplacedDeferral[];
-/**
- * Every `### Phase <id>` section, and every `## <id> — title` section, with its checkboxes. A
- * section runs to the next heading of level three or higher, so a review-gate list or a `####`
- * sub-heading inside the phase still counts. A phase without checkboxes of its own that points at
- * a section (``Siehe `## Dokumentation` ``) counts that section's items, so it is done when the
- * section is. An open checkbox ending in `→ P<n>` is kept under `deferred` and listed in phase `<n>` as open.
- */
-declare const parsePlanPhases: (markdown: string, language: PlanLanguage) => PlanPhase[];
-
 /** A `### Phase` heading (1-based line) whose section has tasks and neither a review gate nor the line saying why not. */
-type PhaseWithoutGate = {
-    line: number;
-    id: string;
-    title: string;
-};
+type PhaseWithoutGate = PhaseHeading;
 /** A row of the lanes table (1-based line) whose phases cell names no phase id. */
-type RowWithoutPhase = {
-    line: number;
-    lane: string;
-    phases: string;
-};
+type RowWithoutPhase = OpenLaneRow;
 /**
  * A `### Phase` heading (1-based line) whose tasks are all ticked on the base branch while its own section still
  * has open checkboxes not moved on with `→ P<n>` (`openLines`, 1-based).
@@ -246,10 +358,8 @@ declare const hasLanesTable: (markdown: string, language: PlanLanguage) => boole
  */
 declare const mergedPhasesWithOpenBoxes: (markdown: string, base: string, language: PlanLanguage) => MergedPhaseWithOpenBoxes[];
 /**
- * The rows of the lanes table (`## Spuren`) that are not in `previousLines` word for word and whose phases cell
- * names no phase id (`P10c`), so neither the view nor the watcher can tie that step to a phase. The table is read
- * as `parseSprintLanes` reads it (its first table, a lane closed when any of its rows says so); rows of a closed
- * lane are history and stay out.
+ * The changed rows of open lanes whose phases cell names no phase id (`P10c`), so neither the view nor the watcher
+ * can tie that step to a phase.
  */
 declare const boardRowsWithoutPhase: (markdown: string, language: PlanLanguage, previousLines: ReadonlySet<string>) => RowWithoutPhase[];
 
@@ -286,13 +396,6 @@ declare const sumPhases: (phases: readonly PhaseProgress[]) => {
     done: number;
     total: number;
 };
-/**
- * The ids of a step that show a phase of their own. An id the plan lacks (`5b`) falls back to its
- * base phase (`5`); when the step already names that phase by its own id, or an earlier id fell
- * back to it, the fallback would list the same tasks twice, so it is dropped. A lone fallback
- * stays: the sprint line `P4a` finds phase 4 in the plans that have no `4a`.
- */
-declare const keptPhaseIds: (phases: PlanPhase[], ids: readonly string[]) => string[];
 /**
  * A phase the lane ticked to the end in its worktree while the base branch does not carry those ticks yet: still
  * the lane's work until it is merged, not a finished phase.
@@ -341,4 +444,4 @@ declare const readSprintDocument: (markdown: string, language: PlanLanguage) =>
  */
 declare const readPhaseDependencies: (planMarkdown: string, language: PlanLanguage) => Record<string, string>;
 
-export { ADDRESS_FORM, type ChecklistItem, type DeferredItem, type DriftFinding, LANGUAGE_NAME, type LaneProgress, type MergedPhaseWithOpenBoxes, type MisplacedDeferral, PHASE_ID_PREFIX, PLAN_LANGUAGE, PLAN_STATUS, PLAN_VOCABULARY, type PhaseProgress, type PhaseTally, type PhaseWithoutGate, type PlanHeader, type PlanLanguage, type PlanPhase, type PlanStatus, type PlanStep, type PlanVocabulary, type PlansByHref, RESPONSE_ADDRESS, type ResponseAddress, type RowWithoutPhase, SELF_MERGE_LABEL, type SprintDocument, type SprintLane, type SprintPlanRow, type SprintPlanTable, type StatusWord, type StepProgress, activeItem, boardRowsWithoutPhase, classifyStatus, countDecisions, currentPhase, currentPhaseOf, deferralTarget, endsPhase, findDrift, hasLanesTable, isCheckboxLine, isOpenCheckboxLine, isPlanLanguage, isReviewGateLine, isTickedUnmerged, keptPhaseIds, laneNameOf, laneProgress, mergedPhasesWithOpenBoxes, misplacedDeferrals, newPhasesWithoutReviewGate, parsePlanPhases, parseSprintLanes, phaseHeading, phaseHeadingPattern, phaseIdsOfCell, phaseIdsOfPlan, readPhaseDependencies, readPlanHeader, readSprintDocument, resolvePlanPath, sectionHeading, shortTitle, sprintTitleOf, sumPhases, tallyPhases, withoutRepeats };
+export { ADDRESS_FORM, APPROVAL_TEXTS, type ChecklistItem, type ColumnModel, type DeferredItem, type DriftFinding, LANGUAGE_NAME, type LaneProgress, type MergedPhaseWithOpenBoxes, type MisplacedDeferral, PHASE_CELL_LIMIT, PHASE_ID_PREFIX, PLAN_LANGUAGE, PLAN_STATUS, PLAN_VOCABULARY, PROSE_REASON, type PhaseDependency, type PhaseHeading, type PhaseProgress, 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, type SprintDocument, type SprintLane, type SprintPlanRow, type SprintPlanTable, type StatusWord, type StepProgress, activeItem, boardRowsWithProse, boardRowsWithoutPhase, classifyStatus, columnModels, countDecisions, currentPhase, currentPhaseOf, deferralTarget, differsFromColumn, endsPhase, findDrift, hasLanesTable, isCheckboxLine, isDocumentationGateItem, isOpenCheckboxLine, isPlanLanguage, isReviewGateLine, isTickedUnmerged, laneNameOf, laneProgress, mergedPhasesWithOpenBoxes, misplacedDeferrals, newPhasesWithoutReviewGate, onlyDocumentationOpen, parallelGroups, parallelGroupsOfPlan, parseDependencyTable, parsePlanPhases, parseSprintLanes, phaseHeading, phaseHeadingPattern, phaseHeadings, phaseIdsOfCell, phaseIdsOfPlan, phasesText, phasesWithoutDependencyRow, readPhaseDependencies, readPlanHeader, readSprintDocument, resolvePlanPath, sectionHeading, shortTitle, sprintTitleOf, sumPhases, tallyPhases, withoutRepeats };