jackherd 0.0.1 → 1.0.1

package/dist/plan-format.js

@@ -0,0 +1,636 @@
+import {
+  LANGUAGE_NAME,
+  PLAN_LANGUAGE,
+  PLAN_STATUS,
+  PLAN_VOCABULARY,
+  classifyStatus,
+  isPlanLanguage,
+  phaseHeading,
+  sectionHeading
+} from "./chunk-R6MGHCD7.js";
+
+// src/plan-format/terminal-text.ts
+var UNSAFE_RANGES = [
+  [0, 31],
+  [127, 159],
+  [1564, 1564],
+  [8206, 8207],
+  [8232, 8233],
+  [8234, 8238],
+  [8294, 8297]
+];
+var escapeCodePoint = (codePoint) => `\\u${codePoint.toString(16).padStart(4, "0")}`;
+var UNSAFE_TERMINAL_TEXT = new RegExp(
+  `[${UNSAFE_RANGES.map(([from, to]) => `${escapeCodePoint(from)}-${escapeCodePoint(to)}`).join("")}]`,
+  "g"
+);
+var terminalSafe = (text) => text.replace(UNSAFE_TERMINAL_TEXT, "");
+
+// src/plan-format/markdown.ts
+var SECTION_END = /^##\s/;
+var TABLE_SEPARATOR = /^\|[\s|:-]+\|$/;
+var escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var sectionStart = (markdown, headingText) => {
+  const heading = new RegExp(`^##\\s+${escapeRegExp(headingText)}\\s*$`);
+  const start = markdown.split("\n").findIndex((line) => heading.test(line));
+  return start === -1 ? -1 : start + 1;
+};
+var sectionLines = (markdown, headingText) => {
+  const start = sectionStart(markdown, headingText);
+  if (start === -1) return [];
+  const rest = markdown.split("\n").slice(start);
+  const end = rest.findIndex((line) => SECTION_END.test(line));
+  return end === -1 ? rest : rest.slice(0, end);
+};
+var tableCells = (line) => line.slice(1, line.endsWith("|") ? -1 : void 0).split("|").map((cell) => terminalSafe(cell).trim());
+var firstTableRows = (lines) => {
+  const start = lines.findIndex((line) => line.startsWith("|"));
+  if (start === -1) return [];
+  const rest = lines.slice(start);
+  const end = rest.findIndex((line) => !line.startsWith("|"));
+  return (end === -1 ? rest : rest.slice(0, end)).map((line, offset) => ({ index: start + offset, line, cells: tableCells(line) })).slice(1).filter(({ line }) => !TABLE_SEPARATOR.test(line));
+};
+var firstTable = (lines) => firstTableRows(lines).map(({ cells }) => cells);
+var headerField = (markdown, name) => {
+  const match = new RegExp(`^\\*\\*${escapeRegExp(name)}:\\*\\*\\s*(.+?)(?=\\n\\*\\*|\\n\\n)`, "ms").exec(markdown);
+  return match ? match[1].replace(/\s+/g, " ").trim() : "";
+};
+var firstHeading = (markdown, fallback) => terminalSafe(markdown.match(/^#\s+(.+)$/m)?.[1] ?? fallback).trim();
+var HEADING = /^(#{2,4})\s+(.*?)\s*$/;
+var subsectionLines = (markdown, headingText) => {
+  const lines = markdown.split("\n");
+  const start = lines.findIndex((line) => HEADING.exec(line)?.[2].startsWith(headingText));
+  if (start === -1) return [];
+  const level = HEADING.exec(lines[start])?.[1].length ?? 2;
+  const rest = lines.slice(start + 1);
+  const end = rest.findIndex((line) => {
+    const heading = HEADING.exec(line);
+    return heading !== null && heading[1].length <= level;
+  });
+  return end === -1 ? rest : rest.slice(0, end);
+};
+var firstTableWithHeader = (lines) => {
+  const start = lines.findIndex((line) => line.startsWith("|"));
+  if (start === -1) return { header: [], rows: [] };
+  return { header: tableCells(lines[start]), rows: firstTable(lines) };
+};
+var allTables = (lines) => {
+  const tables = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    if (!lines[index].startsWith("|") || index > 0 && lines[index - 1].startsWith("|")) continue;
+    const above = lines.slice(0, index).reverse().find((line) => line.trim() !== "");
+    const caption = above && !above.startsWith("|") ? above.trim() : null;
+    tables.push({ caption, ...firstTableWithHeader(lines.slice(index)) });
+  }
+  return tables;
+};
+
+// src/plan-format/drift.ts
+var OPEN_TABLE_CELL = /⬜/;
+var DRIFT_WORDS = {
+  de: {
+    inFlight: /^(Draft|In Progress|Proposed|Open|Planned|Review-Ready|Aktiv)\b/i,
+    completion: /\b(done|abgeschlossen|umgesetzt|implementiert|implemented|fertig)\b/i,
+    open: /\b(offen|ausstehend|deferred|zurückgestellt)\b/i,
+    architecture: /\b(arc42|ADR|Architekturdokumentation|Dokumentation)\b/i,
+    architectureHeading: "Architekturdokumentation",
+    selfReported: (statusText) => `Status nennt offene Doku-Arbeit: "${statusText.trim()}"`,
+    silent: "arc42-Abschlussphase hat offene \u2B1C-Zeilen trotz abgeschlossenem Status"
+  },
+  en: {
+    inFlight: /^(Draft|In Progress|Proposed|Open|Planned|Review-Ready|Active)\b/i,
+    completion: /\b(done|completed|implemented|finished)\b/i,
+    open: /\b(open|outstanding|pending|deferred)\b/i,
+    architecture: /\b(arc42|ADR|architecture documentation|documentation)\b/i,
+    architectureHeading: "Architecture documentation",
+    selfReported: (statusText) => `Status names open documentation work: "${statusText.trim()}"`,
+    silent: "The arc42 closing phase has open \u2B1C rows despite a completed status"
+  }
+};
+var statusLine = (content, name) => content.match(new RegExp(`^\\*\\*${escapeRegExp(name)}:\\*\\*\\s*(.+)$`, "m"))?.[1];
+var architectureSection = (content, heading) => content.match(new RegExp(`#{2,4}[^\\n]*${escapeRegExp(heading)}[^\\n]*\\n([\\s\\S]*?)(?=\\n#{1,4} |$)`))?.[1];
+var findDrift = (file, content, language) => {
+  const statusText = statusLine(content, PLAN_VOCABULARY[language].header.status);
+  const words = DRIFT_WORDS[language];
+  if (!statusText || words.inFlight.test(statusText.trim())) return [];
+  const completed = words.completion.test(statusText);
+  const caveat = words.open.test(statusText);
+  const selfReported = completed && caveat && words.architecture.test(statusText) ? words.selfReported(statusText) : null;
+  const section = completed && !caveat ? architectureSection(content, words.architectureHeading) : void 0;
+  const silent = section && OPEN_TABLE_CELL.test(section) ? words.silent : null;
+  return [selfReported, silent].filter((reason) => reason !== null).map((reason) => ({ file, reason }));
+};
+
+// src/plan-format/header.ts
+var DECISION_ROW = /^\|\s*\*?\*?D\d+/gm;
+var readPlanHeader = (markdown, language, fallbackTitle) => {
+  const { header } = PLAN_VOCABULARY[language];
+  const status = headerField(markdown, header.status);
+  return {
+    title: firstHeading(markdown, fallbackTitle),
+    date: headerField(markdown, header.date),
+    status,
+    statusWord: classifyStatus(language, status),
+    scope: headerField(markdown, header.scope)
+  };
+};
+var countDecisions = (markdown) => (markdown.match(DECISION_ROW) ?? []).length;
+
+// src/plan-format/lanes.ts
+import { posix } from "path";
+var LANE_NAME = /`([^`]+)`/;
+var CONTINUATION = "\u21B3";
+var PLAN_LINK = /\[([^\]]+)\]\(([^)]+)\)/;
+var PHASE_ID_PREFIX = "P";
+var CLAUSE_SEPARATOR = /([;,]|\.(?=\s))\s*/;
+var ENTRY_END = /* @__PURE__ */ new Set([";", "."]);
+var phaseIdPatterns = (language) => {
+  const connectors = PLAN_VOCABULARY[language].phaseConnectors.join("|");
+  const id = `(?:\\*\\*)?${PHASE_ID_PREFIX}(\\d+[a-z]?)\\b`;
+  return {
+    leading: new RegExp(`^\\s*(?:(?:${connectors})\\s+)*${id}`),
+    afterConnector: new RegExp(`^\\s*(?:${connectors})\\s`),
+    connector: new RegExp(`\\b(?:${connectors})\\s+${id}`, "g")
+  };
+};
+var phaseIdsOf = (cell, patterns) => {
+  const parts = cell.split(CLAUSE_SEPARATOR);
+  const ids = [];
+  let listRunning = false;
+  for (let index = 0; index < parts.length; index += 2) {
+    const separator = index > 0 ? parts[index - 1] : null;
+    const clause = parts[index];
+    const entryStart = separator === null || ENTRY_END.has(separator);
+    if (entryStart) listRunning = false;
+    const leading = clause.match(patterns.leading);
+    const startsEntry = entryStart || listRunning || patterns.afterConnector.test(clause);
+    const counts = leading !== null && startsEntry;
+    if (leading && counts) ids.push(leading[1]);
+    ids.push(...[...clause.matchAll(patterns.connector)].map((match) => match[1]));
+    listRunning ||= counts;
+  }
+  return [...new Set(ids)];
+};
+var phaseIdsOfCell = (cell, language) => phaseIdsOf(cell, phaseIdPatterns(language));
+var laneNameOf = (cell, previous) => cell.match(LANE_NAME)?.[1] ?? (cell.startsWith(CONTINUATION) ? previous : null);
+var toStep = ([, , plan = "", phases = "", startsAfter = "", model = ""], phaseId) => {
+  const link = plan.match(PLAN_LINK);
+  return {
+    planTitle: link ? link[1] : plan,
+    planHref: link ? link[2] : null,
+    phaseIds: phaseIdsOf(phases, phaseId),
+    label: phases,
+    startsAfter,
+    model
+  };
+};
+var withoutRepeats = (lane, step) => {
+  const named = new Set(
+    lane.steps.filter((earlier) => earlier.planHref === step.planHref).flatMap((earlier) => earlier.phaseIds)
+  );
+  const phaseIds = step.phaseIds.filter((id) => !named.has(id));
+  if (phaseIds.length === step.phaseIds.length) return step;
+  return { ...step, phaseIds, namedPhaseIds: step.namedPhaseIds ?? step.phaseIds };
+};
+var parseSprintLanes = (markdown, language) => {
+  const lanes = /* @__PURE__ */ new Map();
+  const phaseId = phaseIdPatterns(language);
+  const { laneClosed } = PLAN_VOCABULARY[language];
+  let previous = null;
+  for (const cells of firstTable(sectionLines(markdown, PLAN_VOCABULARY[language].sections.lanes))) {
+    const name = laneNameOf(cells[0] ?? "", previous);
+    if (!name) continue;
+    const port = Number.parseInt(cells[1] ?? "", 10);
+    const lane = lanes.get(name) ?? { name, port: Number.isNaN(port) ? null : port, steps: [], closed: false };
+    lane.closed ||= (cells[0] ?? "").includes(laneClosed);
+    lane.steps.push(withoutRepeats(lane, toStep(cells, phaseId)));
+    lanes.set(name, lane);
+    previous = name;
+  }
+  return [...lanes.values()];
+};
+var sprintTitleOf = (markdown, fallback) => firstHeading(markdown, fallback);
+var resolvePlanPath = (sprintDirectory, href) => posix.normalize(posix.join(sprintDirectory, href.split("#")[0]));
+
+// src/plan-format/phases.ts
+var REVIEW_GATE = /^\s*\*\*review[- ]gate\b/i;
+var PHASE_END = /^#{1,3}\s/;
+var CHECKBOX = /^\s*[-*]\s+\[([ xX])\]\s+(.*)$/;
+var SECTION_HEADING = /^##\s+(.+?)\s*$/;
+var TOP_HEADING = /^#\s/;
+var TABLE_STATUS = { done: "\u2705", open: "\u2B1C" };
+var ROW_NUMBER = /^\d+(\.\d+)*[a-z]?$/;
+var NUMBERED_SECTION = /^##\s+(\d+[a-z]?)\s*[—–:-]\s*(.*)$/;
+var SECTION_POINTER = /`##\s+([^`]+?)\s*`/;
+var DEFERRED_TO = new RegExp(`\\s\u2192\\s*${PHASE_ID_PREFIX}(\\d+[a-z]?)\\s*$`, "i");
+var PHASE_ARROW = new RegExp(`\\s*\u2192\\s*${PHASE_ID_PREFIX}(\\d+[a-z]?)\\b`, "i");
+var isReviewGateLine = (line) => REVIEW_GATE.test(line);
+var endsPhase = (line) => PHASE_END.test(line);
+var isCheckboxLine = (line) => CHECKBOX.test(line);
+var isOpenCheckboxLine = (line) => line.match(CHECKBOX)?.[1] === " ";
+var phaseHeadingPattern = (language) => new RegExp(`^###\\s+${escapeRegExp(PLAN_VOCABULARY[language].phase)}\\s+(\\d+[a-z]?)\\b\\s*[:\u2014\u2013-]?\\s*(.*)$`, "i");
+var tableCells2 = (line) => {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("|")) return null;
+  return trimmed.replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
+};
+var tableItemOf = (line) => {
+  const cells = tableCells2(line);
+  const statusIndex = cells?.findIndex((cell) => cell === TABLE_STATUS.done || cell === TABLE_STATUS.open) ?? -1;
+  if (!cells || statusIndex < 0) return null;
+  const rest = cells.filter((_, index) => index !== statusIndex);
+  const text = (ROW_NUMBER.test(rest[0] ?? "") ? rest.slice(1) : rest).filter((cell) => cell !== "").join(" \xB7 ");
+  return { done: cells[statusIndex] === TABLE_STATUS.done, text: terminalSafe(text).trim() };
+};
+var checkboxItemOf = (line) => {
+  const checkbox = line.match(CHECKBOX);
+  return checkbox ? { done: checkbox[1] !== " ", text: terminalSafe(checkbox[2] ?? "").trim() } : null;
+};
+var checklistItemOf = (line, gate = false) => {
+  const item = checkboxItemOf(line) ?? tableItemOf(line);
+  if (!item) return null;
+  return gate ? { ...item, gate: true } : item;
+};
+var sectionItems = (markdown) => {
+  const sections = /* @__PURE__ */ new Map();
+  let open = null;
+  for (const line of markdown.split("\n")) {
+    const heading = line.match(SECTION_HEADING);
+    if (heading?.[1]) {
+      open = [];
+      sections.set(heading[1], open);
+    } else if (TOP_HEADING.test(line)) {
+      open = null;
+    } else {
+      const item = checklistItemOf(line);
+      if (item) open?.push(item);
+    }
+  }
+  return sections;
+};
+var withPointedSections = (phases, pointers, markdown) => {
+  if (pointers.size === 0) return phases;
+  const sections = sectionItems(markdown);
+  return phases.map((phase) => {
+    const pointer = pointers.get(phase);
+    return phase.items.length === 0 && pointer ? { ...phase, items: sections.get(pointer) ?? [] } : phase;
+  });
+};
+var deferralTarget = (line, phaseId) => {
+  const checkbox = line.match(CHECKBOX);
+  if (checkbox?.[1] !== " ") return null;
+  const target = checkbox[2]?.match(DEFERRED_TO)?.[1]?.toLowerCase();
+  return target && target !== phaseId ? target : null;
+};
+var misplacedDeferralOf = (line, index) => {
+  const checkbox = line.match(CHECKBOX);
+  if (checkbox?.[1] !== " " || DEFERRED_TO.test(checkbox[2])) return [];
+  const arrow = checkbox[2].match(PHASE_ARROW);
+  if (!arrow) return [];
+  const rest = checkbox[2].replace(PHASE_ARROW, "").trim();
+  const marker = line.slice(0, line.length - checkbox[2].length);
+  return [{ line: index + 1, target: arrow[1], corrected: `${marker}${rest} \u2192 ${PHASE_ID_PREFIX}${arrow[1]}` }];
+};
+var misplacedDeferrals = (markdown) => markdown.split("\n").flatMap(misplacedDeferralOf);
+var deferredItemOf = (line, phaseId) => {
+  const target = deferralTarget(line, phaseId);
+  const text = line.match(CHECKBOX)?.[2] ?? "";
+  return target ? { text: terminalSafe(text.replace(DEFERRED_TO, "")).trim(), target } : null;
+};
+var arrivedItem = ({ text }, origin) => ({
+  done: false,
+  text: `${text} \u2190 ${PHASE_ID_PREFIX}${origin.id}`
+});
+var withArrivedItems = (phases) => {
+  const ids = new Set(phases.map(({ id }) => id));
+  const moved = phases.flatMap((origin) => (origin.deferred ?? []).map((item) => ({ origin, item })));
+  if (moved.length === 0) return phases;
+  return phases.map((phase) => {
+    const arriving = moved.filter(({ item }) => item.target === phase.id).map(({ item, origin }) => arrivedItem(item, origin));
+    const stranded = (phase.deferred ?? []).filter(({ target }) => !ids.has(target));
+    const deferred = (phase.deferred ?? []).filter(({ target }) => ids.has(target));
+    const returned = stranded.map(({ text, target }) => ({
+      done: false,
+      text: `${text} \u2192 ${PHASE_ID_PREFIX}${target}`
+    }));
+    const { deferred: _, ...rest } = phase;
+    return { ...rest, items: [...phase.items, ...returned, ...arriving], ...deferred.length > 0 ? { deferred } : {} };
+  });
+};
+var fileLine = (phase, line, gate) => {
+  const deferred = deferredItemOf(line, phase.id);
+  if (deferred) {
+    phase.deferred = [...phase.deferred ?? [], deferred];
+    return;
+  }
+  const item = checklistItemOf(line, gate);
+  if (item) phase.items.push(item);
+};
+var notePointer = (pointers, phase, line) => {
+  const pointer = phase && !pointers.has(phase) ? line.match(SECTION_POINTER)?.[1] : void 0;
+  if (phase && pointer) pointers.set(phase, pointer);
+};
+var headingOf = (line, phaseHeading2) => line.match(phaseHeading2) ?? line.match(NUMBERED_SECTION);
+var parsePlanPhases = (markdown, language) => {
+  const phaseHeading2 = phaseHeadingPattern(language);
+  const pointers = /* @__PURE__ */ new Map();
+  const { phases } = markdown.split("\n").reduce(
+    ({ phases: phases2, open, gate }, line) => {
+      const heading = headingOf(line, phaseHeading2);
+      if (heading) {
+        const phase = { id: (heading[1] ?? "").toLowerCase(), title: terminalSafe(heading[2] ?? "").trim(), items: [] };
+        return { phases: [...phases2, phase], open: phase, gate: false };
+      }
+      if (PHASE_END.test(line)) return { phases: phases2, open: null, gate: false };
+      const inGate = gate || REVIEW_GATE.test(line);
+      if (open) fileLine(open, line, inGate);
+      notePointer(pointers, open, line);
+      return { phases: phases2, open, gate: inGate };
+    },
+    { phases: [], open: null, gate: false }
+  );
+  return withArrivedItems(withPointedSections(phases, pointers, markdown));
+};
+
+// src/plan-format/phase-tally.ts
+var DONE_MARK = /^\s*[-*]\s\[x\]|\|\s*✅\s*\|/gim;
+var OPEN_MARK = /^\s*[-*]\s\[ \]|\|\s*⬜\s*\|/gm;
+var TRAILING_SEPARATOR = /[:—–-]\s*$/;
+var PHASE_ID = /^(\d+[a-z]?)/;
+var modelFor = (markdown, phaseWord, phaseTitle) => {
+  const prefix = new RegExp(`^${escapeRegExp(phaseWord)}\\s*`, "i");
+  const number = /^(\d+)/.exec(phaseTitle.replace(prefix, ""))?.[1];
+  if (!number) return void 0;
+  const row = new RegExp(`^\\|\\s*${number}\\s*[\u2014\u2013-][^|]*\\|\\s*([^|]+?)\\s*\\|`, "m").exec(markdown);
+  return row?.[1].trim();
+};
+var sectionOf = (section, heading, markdown, phaseWord) => {
+  const match = heading.exec(section);
+  if (!match) return null;
+  const title = match[1].replace(TRAILING_SEPARATOR, "").trim();
+  const phaseId = PHASE_ID.exec(title)?.[1]?.toLowerCase() ?? "";
+  const targets = section.split("\n").flatMap((line) => deferralTarget(line, phaseId) ?? []);
+  const done = (section.match(DONE_MARK) ?? []).length;
+  const open = (section.match(OPEN_MARK) ?? []).length - targets.length;
+  return { title, done, open, model: modelFor(markdown, phaseWord, title), phaseId, targets };
+};
+var tallyPhases = (markdown, language) => {
+  const phaseWord = PLAN_VOCABULARY[language].phase;
+  const heading = new RegExp(`^###?\\s+(?:${escapeRegExp(phaseWord)}\\s*)?(\\d+[^\\n]*)`);
+  const sections = markdown.split(/\n(?=###?\s)/).flatMap((section) => sectionOf(section, heading, markdown, phaseWord) ?? []);
+  const ids = new Set(sections.map(({ phaseId }) => phaseId));
+  return sections.flatMap(({ phaseId, targets, ...tally }) => {
+    const stranded = targets.filter((target) => !ids.has(target)).length;
+    const arriving = sections.flatMap((each) => each.targets).filter((target) => target === phaseId).length;
+    const open = tally.open + stranded + arriving;
+    return tally.done + open === 0 ? [] : [{ ...tally, open }];
+  });
+};
+
+// src/plan-format/plan-structure.ts
+var noGatePattern = (language) => new RegExp(`^\\s*\\*\\*${escapeRegExp(PLAN_VOCABULARY[language].noReviewGate)}\\b`, "i");
+var tickCount = (phase) => phase.items.filter((item) => item.done).length;
+var tasksDone = (phase) => {
+  const tasks = phase.items.filter((item) => !item.gate);
+  return tasks.length > 0 && tasks.every((item) => item.done);
+};
+var phaseSections = (markdown, language) => {
+  const heading = phaseHeadingPattern(language);
+  const noGate = noGatePattern(language);
+  const sections = [];
+  let open = null;
+  for (const [index, line] of markdown.split("\n").entries()) {
+    const match = line.match(heading);
+    if (match) {
+      open = {
+        line: index + 1,
+        id: match[1].toLowerCase(),
+        title: terminalSafe(match[2]).trim(),
+        tasks: false,
+        gate: false,
+        openLines: []
+      };
+      sections.push(open);
+    } else if (endsPhase(line)) {
+      open = null;
+    } else if (open) {
+      open.tasks ||= isCheckboxLine(line);
+      open.gate ||= isReviewGateLine(line) || noGate.test(line);
+      if (isOpenCheckboxLine(line) && deferralTarget(line, open.id) === null) open.openLines.push(index + 1);
+    }
+  }
+  return sections;
+};
+var phaseIdsOfPlan = (markdown, language) => new Set(phaseSections(markdown, language).map(({ id }) => id));
+var newPhasesWithoutReviewGate = (markdown, language, previousIds) => phaseSections(markdown, language).filter(({ id, tasks, gate }) => tasks && !gate && !previousIds.has(id)).map(({ line, id, title }) => ({ line, id, title }));
+var hasLanesTable = (markdown, language) => sectionLines(markdown, PLAN_VOCABULARY[language].sections.lanes).some((line) => line.startsWith("|"));
+var mergedPhasesWithOpenBoxes = (markdown, base, language) => {
+  const baseById = new Map(parsePlanPhases(base, language).map((phase) => [phase.id, phase]));
+  const currentById = new Map(parsePlanPhases(markdown, language).map((phase) => [phase.id, phase]));
+  const isMerged = (id) => {
+    const [basePhase, currentPhase2] = [baseById.get(id), currentById.get(id)];
+    return basePhase !== void 0 && currentPhase2 !== void 0 && tasksDone(basePhase) && tickCount(currentPhase2) <= tickCount(basePhase);
+  };
+  return phaseSections(markdown, language).filter(({ id, openLines }) => openLines.length > 0 && isMerged(id)).map(({ line, id, title, openLines }) => ({ line, id, title, openLines }));
+};
+var boardRowsWithoutPhase = (markdown, language, previousLines) => {
+  const start = sectionStart(markdown, PLAN_VOCABULARY[language].sections.lanes);
+  if (start === -1) return [];
+  const closed = new Set(
+    parseSprintLanes(markdown, language).filter((lane) => lane.closed).map((lane) => lane.name)
+  );
+  const rows = [];
+  let previous = null;
+  for (const { index, line, cells } of firstTableRows(
+    sectionLines(markdown, PLAN_VOCABULARY[language].sections.lanes)
+  )) {
+    const [name = "", , , phases = ""] = cells;
+    const lane = laneNameOf(name, previous);
+    previous = lane ?? previous;
+    const counts = lane !== null && !closed.has(lane) && !previousLines.has(line);
+    if (counts && phaseIdsOfCell(phases, language).length === 0) rows.push({ line: start + index + 1, lane, phases });
+  }
+  return rows;
+};
+
+// src/plan-format/progress.ts
+var sumPhases = (phases) => ({
+  done: phases.reduce((sum, phase) => sum + phase.done, 0),
+  total: phases.reduce((sum, phase) => sum + phase.total, 0)
+});
+var baseId = (id) => id.replace(/[a-z]$/, "");
+var findPhase = (phases, id) => phases.find((phase) => phase.id === id) ?? phases.find((phase) => phase.id === baseId(id));
+var keptPhaseIds = (phases, ids) => {
+  const shown = new Set(ids.flatMap((id) => phases.filter((phase) => phase.id === id)));
+  return ids.filter((id) => {
+    const phase = findPhase(phases, id);
+    if (!phase || phase.id === id) return true;
+    if (shown.has(phase)) return false;
+    shown.add(phase);
+    return true;
+  });
+};
+var phaseProgress = (phases, id) => {
+  const phase = findPhase(phases, id);
+  const items = phase?.items ?? [];
+  return {
+    id,
+    title: phase?.title ?? null,
+    done: items.filter((item) => item.done).length,
+    total: items.length,
+    items,
+    ...phase?.deferred ? { deferred: phase.deferred } : {},
+    ...phase?.touched ? { touched: true } : {}
+  };
+};
+var isOpen = ({ done, total }) => done < total;
+var isWritten = ({ total }) => total > 0;
+var newestWrittenStepIndex = (steps) => steps.reduce((last, { phases }, index) => phases.some(isWritten) ? index : last, -1);
+var newestRowIndex = (steps) => steps.reduce((last, { step }, index) => step.withoutRow ? last : index, -1);
+var isTouched = (phase) => phase.touched === true && isWritten(phase);
+var isTickedUnmerged = (phase) => isTouched(phase) && !isOpen(phase);
+var newestStepWith = (steps, pick) => {
+  for (let stepIndex = steps.length - 1; stepIndex >= 0; stepIndex--) {
+    const phase = pick(steps[stepIndex].phases);
+    if (phase) return { stepIndex, phaseId: phase.id };
+  }
+  return null;
+};
+var shownPhase = (phases, id) => phases.find((phase) => phase.id === id) ?? phases.find((phase) => phase.id === baseId(id));
+var earlierPhase = (steps, before, id) => {
+  const planHref = steps[before].step.planHref;
+  for (let stepIndex = before - 1; stepIndex >= 0; stepIndex--) {
+    if (steps[stepIndex].step.planHref !== planHref) continue;
+    const phase = shownPhase(steps[stepIndex].phases, id);
+    if (phase) return { phase, current: { stepIndex, phaseId: phase.id } };
+  }
+  return null;
+};
+var rowPhases = (steps, stepIndex) => {
+  const row = steps[stepIndex];
+  if (!row) return [];
+  const own = row.phases.map((phase) => ({ phase, current: { stepIndex, phaseId: phase.id } }));
+  const named = row.step.namedPhaseIds;
+  if (!named) return own;
+  return named.flatMap((id) => {
+    const located = own.find((entry) => entry.phase.id === id) ?? earlierPhase(steps, stepIndex, id);
+    return located ? [located] : [];
+  });
+};
+var touchedOpenPhaseOf = (phases) => phases.find((phase) => isTouched(phase) && isOpen(phase));
+var lastTickedUnmergedOf = (phases) => phases.filter(isTickedUnmerged).at(-1);
+var newestRowPhase = (steps) => {
+  const located = rowPhases(steps, newestRowIndex(steps)).filter(({ phase: phase2 }) => isWritten(phase2));
+  const phases = located.map(({ phase: phase2 }) => phase2);
+  const phase = touchedOpenPhaseOf(phases) ?? lastTickedUnmergedOf(phases) ?? phases.find(isOpen);
+  return located.find((entry) => entry.phase === phase)?.current ?? null;
+};
+var phaseFromTicks = (steps) => {
+  const touched = newestStepWith(steps, touchedOpenPhaseOf) ?? newestStepWith(steps, lastTickedUnmergedOf);
+  if (touched) return touched;
+  const lastIndex = newestWrittenStepIndex(steps);
+  const phase = steps[lastIndex]?.phases.find(isOpen);
+  return phase ? { stepIndex: lastIndex, phaseId: phase.id } : null;
+};
+var currentPhaseOf = (steps) => newestRowPhase(steps) ?? phaseFromTicks(steps);
+var laneProgress = (lane, plans) => {
+  const steps = lane.steps.map((step) => {
+    const phases = step.planHref ? plans[step.planHref] : void 0;
+    return { step, phases: phases ? keptPhaseIds(phases, step.phaseIds).map((id) => phaseProgress(phases, id)) : [] };
+  });
+  return { lane, steps, current: currentPhaseOf(steps), ...sumPhases(steps.flatMap((step) => step.phases)) };
+};
+var currentPhase = (progress) => {
+  if (!progress.current) return null;
+  const { stepIndex, phaseId } = progress.current;
+  return progress.steps[stepIndex].phases.find((phase) => phase.id === phaseId) ?? null;
+};
+var activeItem = (phase) => phase.items.find((item) => !item.done) ?? null;
+var shortTitle = (progress) => {
+  const phase = currentPhase(progress);
+  if (phase) return `${PHASE_ID_PREFIX}${phase.id} \xB7 ${phase.done}/${phase.total}`;
+  return progress.total > 0 ? `\u2713 ${progress.done}/${progress.total}` : null;
+};
+
+// src/plan-format/sprint-document.ts
+var PHASE_ID_IN_CELL = /^(\d+[a-z]?)\b/;
+var paragraphs = (lines) => lines.join("\n").split(/\n\s*\n/).map((paragraph) => paragraph.trim()).filter(Boolean);
+var PLAN_LINK2 = /\[([^\]]+)\]\(([^)\s]+)\)/;
+var planRowOf = (cells) => {
+  const link = cells.map((cell) => PLAN_LINK2.exec(cell)).find((match) => match !== null);
+  return { cells, title: link?.[1] ?? null, href: link?.[2] ?? null };
+};
+var textBeforeFirstSection = (markdown) => {
+  const lines = markdown.split("\n");
+  const end = lines.findIndex((line) => /^##\s/.test(line));
+  const intro = (end === -1 ? lines : lines.slice(0, end)).filter((line) => !/^#\s/.test(line));
+  return paragraphs(intro).filter((paragraph) => !/^\*\*[^*]+:\*\*/.test(paragraph));
+};
+var readSprintDocument = (markdown, language) => {
+  const { goal, history, plans } = PLAN_VOCABULARY[language].sections;
+  const goalParagraphs = paragraphs(sectionLines(markdown, goal));
+  return {
+    planTables: allTables(sectionLines(markdown, plans)).map(({ caption, header, rows }) => ({
+      caption,
+      header,
+      rows: rows.map(planRowOf)
+    })),
+    goal: goalParagraphs.length > 0 ? goalParagraphs : textBeforeFirstSection(markdown),
+    history: firstTableWithHeader(sectionLines(markdown, history))
+  };
+};
+var readPhaseDependencies = (planMarkdown, language) => {
+  const { sections, columns } = PLAN_VOCABULARY[language];
+  const { header, rows } = firstTableWithHeader(subsectionLines(planMarkdown, sections.dependencies));
+  const column = header.indexOf(columns.dependsOn);
+  if (column === -1) return {};
+  const entries = rows.flatMap((cells) => {
+    const id = PHASE_ID_IN_CELL.exec(cells[0] ?? "")?.[1];
+    return id ? [[id, cells[column] ?? ""]] : [];
+  });
+  return Object.fromEntries(entries);
+};
+export {
+  LANGUAGE_NAME,
+  PHASE_ID_PREFIX,
+  PLAN_LANGUAGE,
+  PLAN_STATUS,
+  PLAN_VOCABULARY,
+  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
+};

package/docs/lanes.mmd

@@ -0,0 +1,9 @@
+flowchart LR
+  coordinator[Coordinator<br/>/orchestrate] -- prompts --> laneA[Lane a<br/>worktree a]
+  coordinator -- open decisions,<br/>one approval per PR --> user([You])
+  coordinator -- prompts --> laneB[Lane b<br/>worktree b]
+  laneA -- questions as text --> coordinator
+  laneB -- questions as text --> coordinator
+  watcher[jh watch] -- wakes --> coordinator
+  laneA -. state, PR, checks .-> watcher
+  laneB -. state, PR, checks .-> watcher