@papi-ai/adapter-md 0.1.0-alpha

package/dist/index.js

@@ -0,0 +1,2398 @@
+// src/adapter.ts
+import { readFile, writeFile, access } from "fs/promises";
+import { randomUUID as randomUUID6 } from "crypto";
+import { join } from "path";
+
+// src/types.ts
+import {
+  VALID_TRANSITIONS as _VALID_TRANSITIONS,
+  isValidTransition as _isValidTransition,
+  validateTransition as _validateTransition,
+  isValidStatus as _isValidStatus
+} from "@papi-ai/shared";
+var VALID_TRANSITIONS = _VALID_TRANSITIONS;
+var isValidTransition = _isValidTransition;
+var validateTransition = _validateTransition;
+var isValidStatus = _isValidStatus;
+var TASK_TYPE_TIERS = {
+  bug: 1,
+  task: 1,
+  research: 2,
+  idea: 3,
+  feedback: 3
+};
+
+// src/parsers/planning-log.ts
+import { randomUUID } from "crypto";
+function extractSection(content, heading) {
+  const headingPattern = new RegExp(`^## ${heading}\\s*$`, "m");
+  const start = content.search(headingPattern);
+  if (start === -1) return "";
+  const afterHeading = content.slice(start);
+  const nextSection = afterHeading.slice(1).search(/^## /m);
+  return nextSection === -1 ? afterHeading : afterHeading.slice(0, nextSection + 1);
+}
+function extractSectionCompat(content, newHeading, legacyHeading) {
+  const section = extractSection(content, newHeading);
+  return section || extractSection(content, legacyHeading);
+}
+function parseSprintHealth(content) {
+  const section = extractSectionCompat(content, "Sprint Health", "Session Health");
+  const rows = /* @__PURE__ */ new Map();
+  for (const line of section.split("\n")) {
+    const match = line.match(/^\|\s*(.+?)\s*\|\s*(.+?)\s*\|$/);
+    if (!match) continue;
+    const key = match[1].trim().toLowerCase();
+    const value = match[2].trim();
+    if (key !== "metric") rows.set(key, value);
+  }
+  const get = (key) => rows.get(key) ?? "";
+  return {
+    totalSprints: parseInt(get("total sprints") || get("total sessions"), 10) || 0,
+    sprintsSinceLastStrategyReview: parseInt(get("sprints since last strategy review") || get("sessions since last strategy review"), 10) || 0,
+    strategyReviewDue: get("strategy review due"),
+    boardHealth: get("board health"),
+    strategicDirection: get("strategic direction"),
+    lastFullMode: parseInt(get("last full mode"), 10) || 0
+  };
+}
+function serializeSprintHealth(health, content) {
+  const section = extractSectionCompat(content, "Sprint Health", "Session Health");
+  const fieldMap = {
+    "Total sprints": String(health.totalSprints),
+    "Sprints since last Strategy Review": String(health.sprintsSinceLastStrategyReview),
+    "Strategy Review due": health.strategyReviewDue,
+    "Board health": health.boardHealth,
+    "Strategic direction": health.strategicDirection,
+    "Last Full Mode": String(health.lastFullMode)
+  };
+  const legacyFieldMap = {
+    "Total sessions": String(health.totalSprints),
+    "Sessions since last Strategy Review": String(health.sprintsSinceLastStrategyReview)
+  };
+  let updatedSection = section;
+  for (const [metric, value] of Object.entries({ ...fieldMap, ...legacyFieldMap })) {
+    const pattern = new RegExp(`(\\|\\s*${metric}\\s*\\|\\s*)(.+?)(\\s*\\|)`, "i");
+    updatedSection = updatedSection.replace(pattern, `$1${value}$3`);
+  }
+  return content.replace(section, updatedSection);
+}
+function parseActiveDecisions(content) {
+  const section = extractSection(content, "Active Decisions");
+  const chunks = section.split(/^(?=### AD-\d+:)/m).map((c) => c.trim()).filter((c) => c.startsWith("### AD-"));
+  return chunks.map((block) => {
+    const headingMatch = block.match(
+      /^### (AD-\d+):\s*(.+?)(?:\s*\[Confidence:\s*(HIGH|MEDIUM|LOW)\])?(?:\s*\[SUPERSEDED by (AD-\d+)\])?\s*$/m
+    );
+    if (!headingMatch) return null;
+    const metaMatch = block.match(/<!-- papi:(?:created_sprint=(\d+))?\s*(?:modified_sprint=(\d+)\s*)*(?:uuid=(\S+))? -->/);
+    const createdSprint = metaMatch?.[1] ? parseInt(metaMatch[1], 10) : void 0;
+    const modifiedSprint = metaMatch?.[2] ? parseInt(metaMatch[2], 10) : void 0;
+    const uuid = metaMatch?.[3] ?? randomUUID();
+    return {
+      uuid,
+      id: headingMatch[1],
+      displayId: headingMatch[1],
+      title: headingMatch[2].trim(),
+      confidence: headingMatch[3] ?? "HIGH",
+      superseded: !!headingMatch[4],
+      supersededBy: headingMatch[4],
+      createdSprint,
+      modifiedSprint,
+      body: block
+    };
+  }).filter((d) => d !== null);
+}
+function stripTemporalMeta(body) {
+  return body.replace(/\n?<!-- papi:(?:created_sprint=\d+)?\s*(?:modified_sprint=\d+\s*)*(?:uuid=\S+)? -->/g, "");
+}
+function buildTemporalMeta(createdSprint, modifiedSprint, uuid) {
+  const parts = [];
+  if (createdSprint != null) parts.push(`created_sprint=${createdSprint}`);
+  if (modifiedSprint != null) parts.push(`modified_sprint=${modifiedSprint}`);
+  if (uuid) parts.push(`uuid=${uuid}`);
+  if (parts.length === 0) return "";
+  return `
+<!-- papi:${parts.join(" ")} -->`;
+}
+function extractCreatedSprint(block) {
+  const m = block.match(/<!-- papi:(?:created_sprint=(\d+))/);
+  return m?.[1] ? parseInt(m[1], 10) : void 0;
+}
+function extractUuid(block) {
+  const m = block.match(/<!-- papi:.*?uuid=(\S+)/);
+  return m?.[1];
+}
+function updateActiveDecisionInContent(id, newBody, content, sprintNumber) {
+  if (!newBody) return content;
+  const escapedId = id.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+  const pattern = new RegExp(`(### ${escapedId}:.*?)(?=^### AD-\\d+:|^## |$(?![\\s\\S]))`, "ms");
+  const cleanBody = stripTemporalMeta(newBody);
+  if (pattern.test(content)) {
+    const existingMatch = content.match(pattern);
+    const existingCreated = existingMatch ? extractCreatedSprint(existingMatch[0]) : void 0;
+    const existingUuid = existingMatch ? extractUuid(existingMatch[0]) : void 0;
+    const meta2 = sprintNumber != null ? buildTemporalMeta(existingCreated, sprintNumber, existingUuid) : existingUuid ? buildTemporalMeta(existingCreated, void 0, existingUuid) : "";
+    return content.replace(pattern, cleanBody.trimEnd() + meta2 + "\n\n");
+  }
+  const meta = sprintNumber != null ? buildTemporalMeta(sprintNumber) : "";
+  const sectionPattern = /^(#{1,2} Active Decisions\n)([\s\S]*?)(?=^#{1,2} |$(?![\s\S]))/m;
+  const sectionMatch = content.match(sectionPattern);
+  if (sectionMatch) {
+    const sectionHeader = sectionMatch[1];
+    const sectionBody = sectionMatch[2];
+    const newSection = sectionHeader + sectionBody.trimEnd() + "\n\n" + cleanBody.trimEnd() + meta + "\n\n";
+    return content.replace(sectionPattern, newSection);
+  }
+  return content;
+}
+function parseSprintLog(content, limit) {
+  const section = extractSectionCompat(content, "Sprint Log", "Session Log");
+  const chunks = section.split(/^(?=### (?:Sprint|Session) \d+ —)/m).map((c) => c.trim()).filter((c) => c.match(/^### (?:Sprint|Session) \d+ —/));
+  const entries = chunks.map((block) => {
+    const headingMatch = block.match(/^### (?:Sprint|Session) (\d+) — (.+?)$/m);
+    const sprintNumber = headingMatch ? parseInt(headingMatch[1], 10) : 0;
+    const title = headingMatch ? headingMatch[2].trim() : block.split("\n")[0].replace(/^### /, "");
+    const carryForwardMatch = block.match(/^- \*\*CARRY FORWARD:\*\*\s*(.+)$/m);
+    const uuidMatch = block.match(/<!-- papi:.*?uuid=(\S+)/);
+    const uuid = uuidMatch?.[1];
+    const blockClean = block.replace(/\n?<!-- papi:.*?-->/g, "");
+    const notesMatch = blockClean.match(/\*\*Sprint Notes:\*\*\s*([\s\S]*?)$/);
+    const notes = notesMatch ? notesMatch[1].trim() : void 0;
+    return {
+      uuid: uuid ?? randomUUID(),
+      sprintNumber,
+      title,
+      content: block,
+      carryForward: carryForwardMatch ? carryForwardMatch[1].trim() : void 0,
+      notes
+    };
+  });
+  return limit ? entries.slice(0, limit) : entries;
+}
+function prependSprintLogEntry(entry, content) {
+  const headingPattern = /^## (?:Sprint|Session) Log\s*$/m;
+  const headingMatch = content.match(headingPattern);
+  if (!headingMatch || headingMatch.index === void 0) {
+    throw new Error("Sprint Log section not found in Planning Log");
+  }
+  const insertPos = headingMatch.index + headingMatch[0].length;
+  const before = content.slice(0, insertPos);
+  const after = content.slice(insertPos);
+  let entryContent = entry.content;
+  if (entry.notes) {
+    entryContent = `${entryContent}
+
+**Sprint Notes:** ${entry.notes}`;
+  }
+  if (entry.uuid) {
+    entryContent = `${entryContent}
+<!-- papi:uuid=${entry.uuid} -->`;
+  }
+  return `${before}
+
+${entryContent}
+${after}`;
+}
+function parseNorthStar(content) {
+  return extractSection(content, "North Star").replace(/^## North Star\s*/m, "").trim();
+}
+function parseDeferred(content) {
+  const section = extractSection(content, "Deferred / Parking Lot");
+  return section.split("\n").filter((line) => line.match(/^-\s+/)).map((line) => line.replace(/^-\s+/, "").trim());
+}
+function compressSprintLogInContent(content, threshold, summary) {
+  const section = extractSectionCompat(content, "Sprint Log", "Session Log");
+  const chunks = section.split(/^(?=### (?:Sprint|Session) \d+ —)/m).map((c) => c.trim()).filter((c) => c.match(/^### (?:Sprint|Session) \d+ —/));
+  const keep = [];
+  let hasOld = false;
+  for (const block of chunks) {
+    const match = block.match(/^### (?:Sprint|Session) (\d+) —/);
+    const num = match ? parseInt(match[1], 10) : 0;
+    if (num >= threshold) {
+      keep.push(block);
+    } else {
+      hasOld = true;
+    }
+  }
+  if (!hasOld) return content;
+  const summaryBlock = `### Sprints 1\u2013${threshold - 1} \u2014 Compressed Summary
+
+${summary}`;
+  const newEntries = [...keep, summaryBlock].join("\n\n");
+  const newSection = `## Sprint Log
+
+${newEntries}
+`;
+  return content.replace(section, newSection);
+}
+function parsePlanningLog(content, activeDecisionsContent, sprintLogContent) {
+  return {
+    sprintHealth: parseSprintHealth(content),
+    northStar: parseNorthStar(content),
+    activeDecisions: parseActiveDecisions(activeDecisionsContent ?? content),
+    deferred: parseDeferred(content),
+    sprintLog: sprintLogContent ? parseSprintLog(sprintLogContent) : []
+  };
+}
+
+// src/parsers/sprint-board.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import yaml from "js-yaml";
+
+// src/parsers/build-handoff.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var VALID_EFFORT_SIZES = /* @__PURE__ */ new Set(["XS", "S", "M", "L", "XL"]);
+var SECTION_HEADERS = [
+  "SCOPE (DO THIS)",
+  "SCOPE BOUNDARY (DO NOT DO THIS)",
+  "ACCEPTANCE CRITERIA",
+  "SECURITY CONSIDERATIONS",
+  "FILES LIKELY TOUCHED",
+  "EFFORT"
+];
+function splitSections(text) {
+  const sections = /* @__PURE__ */ new Map();
+  const lines = text.split("\n");
+  let currentSection = null;
+  const sectionLines = [];
+  const flush = () => {
+    if (currentSection !== null) {
+      sections.set(currentSection, sectionLines.join("\n").trim());
+      sectionLines.length = 0;
+    }
+  };
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const matched = SECTION_HEADERS.find((h) => trimmed === h);
+    if (matched) {
+      flush();
+      currentSection = matched;
+    } else if (currentSection !== null) {
+      sectionLines.push(line);
+    }
+  }
+  flush();
+  return sections;
+}
+function parseBulletList(text) {
+  return text.split("\n").map((l) => l.replace(/^\s*-\s*/, "").trim()).filter((l) => l.length > 0);
+}
+function parseChecklist(text) {
+  return text.split("\n").map((l) => l.replace(/^\s*\[[ x]]\s*/, "").trim()).filter((l) => l.length > 0);
+}
+function parseBuildHandoff(markdown) {
+  if (!markdown.includes("BUILD HANDOFF")) return null;
+  const taskIdMatch = markdown.match(/BUILD HANDOFF\s*—\s*(task-\d+)/);
+  const taskTitleMatch = markdown.match(/^Task:\s*(.+)$/m);
+  const sprintMatch = markdown.match(/^Sprint:\s*(\d+)$/m);
+  const whyNowMatch = markdown.match(/^Why now:\s*([\s\S]*?)(?=\n\n|\nSCOPE)/m);
+  const taskId = taskIdMatch?.[1] ?? "";
+  const taskTitle = taskTitleMatch?.[1]?.trim() ?? "";
+  const sprint = sprintMatch ? parseInt(sprintMatch[1], 10) : 0;
+  const whyNow = whyNowMatch?.[1]?.replace(/\s+/g, " ").trim() ?? "";
+  const uuidMatch = markdown.match(/^UUID:\s*(\S+)$/m);
+  const uuid = uuidMatch?.[1];
+  const displayIdMatch = markdown.match(/^Display ID:\s*(\S+)$/m);
+  const displayId = displayIdMatch?.[1];
+  const createdAtMatch = markdown.match(/^Created:\s*(.+)$/m);
+  const createdAt = createdAtMatch?.[1]?.trim();
+  const sections = splitSections(markdown);
+  const effortText = (sections.get("EFFORT") ?? "").trim().toUpperCase();
+  const effort = VALID_EFFORT_SIZES.has(effortText) ? effortText : "M";
+  return {
+    uuid: uuid ?? randomUUID2(),
+    ...displayId ? { displayId } : {},
+    ...createdAt ? { createdAt } : {},
+    taskId,
+    taskTitle,
+    sprint,
+    whyNow,
+    scope: parseBulletList(sections.get("SCOPE (DO THIS)") ?? ""),
+    scopeBoundary: parseBulletList(sections.get("SCOPE BOUNDARY (DO NOT DO THIS)") ?? ""),
+    acceptanceCriteria: parseChecklist(sections.get("ACCEPTANCE CRITERIA") ?? ""),
+    securityConsiderations: (sections.get("SECURITY CONSIDERATIONS") ?? "").trim(),
+    filesLikelyTouched: parseBulletList(sections.get("FILES LIKELY TOUCHED") ?? ""),
+    effort
+  };
+}
+function serializeBuildHandoff(handoff) {
+  const lines = [];
+  lines.push(`BUILD HANDOFF \u2014 ${handoff.taskId}`);
+  if (handoff.uuid) lines.push(`UUID: ${handoff.uuid}`);
+  if (handoff.displayId) lines.push(`Display ID: ${handoff.displayId}`);
+  if (handoff.createdAt) lines.push(`Created: ${handoff.createdAt}`);
+  lines.push(`Task: ${handoff.taskTitle}`);
+  lines.push(`Sprint: ${handoff.sprint}`);
+  lines.push(`Why now: ${handoff.whyNow}`);
+  lines.push("");
+  lines.push("SCOPE (DO THIS)");
+  for (const item of handoff.scope) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+  lines.push("SCOPE BOUNDARY (DO NOT DO THIS)");
+  for (const item of handoff.scopeBoundary) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+  lines.push("ACCEPTANCE CRITERIA");
+  for (const item of handoff.acceptanceCriteria) {
+    lines.push(`[ ] ${item}`);
+  }
+  lines.push("");
+  lines.push("SECURITY CONSIDERATIONS");
+  lines.push(handoff.securityConsiderations);
+  lines.push("");
+  lines.push("FILES LIKELY TOUCHED");
+  for (const item of handoff.filesLikelyTouched) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+  lines.push("EFFORT");
+  lines.push(handoff.effort);
+  return lines.join("\n");
+}
+
+// src/parsers/sprint-board.ts
+var YAML_MARKER = "<!-- PAPI-ADAPTER: parse the yaml block below -->";
+var YAML_START = "<!-- PAPI-YAML-START -->";
+var YAML_END = "<!-- PAPI-YAML-END -->";
+function toSprintTask(raw) {
+  return {
+    uuid: raw.uuid || randomUUID3(),
+    id: raw.id,
+    displayId: raw.id,
+    title: raw.title,
+    status: raw.status,
+    priority: raw.priority,
+    complexity: raw.complexity,
+    module: raw.module,
+    epic: raw.epic,
+    phase: raw.phase,
+    owner: raw.owner,
+    reviewed: raw.reviewed ?? false,
+    sprint: raw.sprint != null ? raw.sprint : void 0,
+    createdSprint: raw.created_sprint != null ? raw.created_sprint : void 0,
+    createdAt: raw.created_at || void 0,
+    why: raw.why || void 0,
+    dependsOn: raw.depends_on || void 0,
+    notes: raw.notes || void 0,
+    stateHistory: raw.state_history?.length ? raw.state_history.map((e) => ({ status: e.status, timestamp: e.timestamp })) : void 0,
+    closureReason: raw.closure_reason || void 0,
+    buildHandoff: raw.build_handoff ? parseBuildHandoff(raw.build_handoff) ?? void 0 : void 0,
+    buildReport: raw.build_report || void 0
+  };
+}
+function sanitizeDelimiters(value) {
+  return value.replaceAll(YAML_END, "<!-- PAPI-YAML-END (sanitized) -->");
+}
+function fromSprintTask(task) {
+  const raw = {
+    uuid: task.uuid,
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    priority: task.priority,
+    complexity: task.complexity,
+    module: task.module,
+    epic: task.epic,
+    phase: task.phase,
+    owner: task.owner,
+    reviewed: task.reviewed,
+    depends_on: task.dependsOn ?? "",
+    notes: task.notes ? sanitizeDelimiters(task.notes) : ""
+  };
+  if (task.sprint != null) raw.sprint = task.sprint;
+  if (task.createdSprint != null) raw.created_sprint = task.createdSprint;
+  if (task.createdAt) raw.created_at = task.createdAt;
+  if (task.why) raw.why = task.why;
+  if (task.stateHistory?.length) {
+    raw.state_history = task.stateHistory.map((e) => ({ status: e.status, timestamp: e.timestamp }));
+  }
+  if (task.closureReason) raw.closure_reason = task.closureReason;
+  if (task.buildHandoff) raw.build_handoff = sanitizeDelimiters(serializeBuildHandoff(task.buildHandoff));
+  if (task.buildReport) raw.build_report = sanitizeDelimiters(task.buildReport);
+  return raw;
+}
+function mergeConflictHint(content) {
+  if (/^[<=>]{7}/m.test(content)) {
+    return " The file contains merge conflict markers (<<<<<<, ======, >>>>>>) \u2014 resolve them first.";
+  }
+  return "";
+}
+function extractYamlBlock(content) {
+  const markerIdx = content.indexOf(YAML_MARKER);
+  if (markerIdx === -1) throw new Error("PAPI-ADAPTER marker not found in SPRINT_BOARD.md");
+  const afterMarker = content.slice(markerIdx + YAML_MARKER.length);
+  const startIdx = afterMarker.indexOf(YAML_START);
+  if (startIdx !== -1) {
+    const yamlStart = startIdx + YAML_START.length;
+    const endIdx = afterMarker.indexOf(YAML_END, yamlStart);
+    if (endIdx === -1) throw new Error("PAPI-YAML-END marker not found in SPRINT_BOARD.md");
+    return afterMarker.slice(yamlStart, endIdx);
+  }
+  const blockMatch = afterMarker.match(/```yaml\n([\s\S]*?)```/);
+  if (!blockMatch) throw new Error("YAML block not found in SPRINT_BOARD.md");
+  return blockMatch[1];
+}
+function parseBoard(content) {
+  const yamlText = extractYamlBlock(content);
+  let data;
+  try {
+    data = yaml.load(yamlText);
+  } catch (err) {
+    const yamlErr = err;
+    const lineInfo = yamlErr.mark?.line != null ? ` (near line ${yamlErr.mark.line + 1} of YAML block)` : "";
+    const hint = mergeConflictHint(yamlText);
+    throw new Error(
+      `YAML parse error in SPRINT_BOARD.md${lineInfo}. Check for syntax errors \u2014 unquoted special characters, bad indentation, or missing colons.${hint}`
+    );
+  }
+  return (data.tasks ?? []).map(toSprintTask);
+}
+function serializeBoard(tasks, content) {
+  const raw = tasks.map(fromSprintTask);
+  const yamlStr = yaml.dump({ tasks: raw }, { lineWidth: 120, quotingType: '"' });
+  const markerIdx = content.indexOf(YAML_MARKER);
+  if (markerIdx === -1) throw new Error("PAPI-ADAPTER marker not found in SPRINT_BOARD.md");
+  const afterMarker = content.slice(markerIdx + YAML_MARKER.length);
+  const htmlStartIdx = afterMarker.indexOf(YAML_START);
+  if (htmlStartIdx !== -1) {
+    const absStart = markerIdx + YAML_MARKER.length + htmlStartIdx;
+    const endIdx = afterMarker.indexOf(YAML_END, htmlStartIdx);
+    if (endIdx === -1) throw new Error("PAPI-YAML-END marker not found in SPRINT_BOARD.md");
+    const absEnd = markerIdx + YAML_MARKER.length + endIdx + YAML_END.length;
+    return content.slice(0, absStart) + YAML_START + "\n" + yamlStr + YAML_END + content.slice(absEnd);
+  }
+  const blockMatch = afterMarker.match(/```yaml\n[\s\S]*?```/);
+  if (!blockMatch) throw new Error("YAML block not found in SPRINT_BOARD.md");
+  const blockStart = markerIdx + YAML_MARKER.length + afterMarker.indexOf(blockMatch[0]);
+  const blockEnd = blockStart + blockMatch[0].length;
+  return content.slice(0, blockStart) + YAML_START + "\n" + yamlStr + YAML_END + content.slice(blockEnd);
+}
+function filterTasks(tasks, options) {
+  return tasks.filter((task) => {
+    if (options.status && !options.status.includes(task.status)) return false;
+    if (options.priority && !options.priority.includes(task.priority)) return false;
+    if (options.phase && !task.phase.toLowerCase().includes(options.phase.toLowerCase())) return false;
+    if (options.reviewed !== void 0 && task.reviewed !== options.reviewed) return false;
+    if (options.module && task.module !== options.module) return false;
+    if (options.epic && task.epic !== options.epic) return false;
+    return true;
+  });
+}
+function nextTaskId(tasks) {
+  const maxN = tasks.reduce((max, t) => {
+    const match = t.id.match(/^task-(\d+)$/);
+    return match ? Math.max(max, parseInt(match[1], 10)) : max;
+  }, 0);
+  return `task-${String(maxN + 1).padStart(3, "0")}`;
+}
+
+// src/parsers/build-reports.ts
+import { randomUUID as randomUUID4 } from "crypto";
+var VALID_EFFORT_SIZES2 = /* @__PURE__ */ new Set(["XS", "S", "M", "L", "XL"]);
+function parseEffortSize(value) {
+  const normalized = value.trim().toUpperCase();
+  return VALID_EFFORT_SIZES2.has(normalized) ? normalized : void 0;
+}
+var HEADER_SENTINEL = "*After each build";
+function parseField(block, field) {
+  const pattern = new RegExp(`^- \\*\\*${field}:\\*\\*\\s*(.+)$`, "m");
+  const match = block.match(pattern);
+  return match ? match[1].trim() : "";
+}
+function parseEffort(effortLine) {
+  const match = effortLine.match(/^(\S+)\s+vs\s+estimated\s+(\S+)$/i);
+  return match ? { actual: match[1], estimated: match[2] } : { actual: effortLine, estimated: "" };
+}
+function parseBuildReports(content) {
+  const chunks = content.split(/^(?=### .+ — .+ — (?:Sprint|Session) \d+)/m).map((c) => c.trim()).filter((c) => c.match(/^### .+ — .+ — (?:Sprint|Session) \d+/));
+  return chunks.map((block) => {
+    const headingMatch = block.match(/^### (.+?) — (.+?) — (?:Sprint|Session) (\d+)/);
+    if (!headingMatch) return null;
+    const effortLine = parseField(block, "Actual Effort");
+    const { actual, estimated } = parseEffort(effortLine);
+    const completedRaw = parseField(block, "Completed");
+    const taskId = parseField(block, "Task ID") || "unknown";
+    const uuidRaw = parseField(block, "UUID");
+    const displayIdRaw = parseField(block, "Display ID");
+    const scopeAccuracyRaw = parseField(block, "Scope Accuracy");
+    const validScopeValues = /* @__PURE__ */ new Set(["accurate", "over-scoped", "under-scoped", "missed-context"]);
+    const scopeAccuracy = scopeAccuracyRaw && validScopeValues.has(scopeAccuracyRaw) ? scopeAccuracyRaw : "accurate";
+    const actualEffort = parseEffortSize(actual) ?? "M";
+    const estimatedEffort = parseEffortSize(estimated) ?? "M";
+    const createdAtRaw = parseField(block, "Created");
+    const commitShaRaw = parseField(block, "Commit SHA");
+    const filesChangedRaw = parseField(block, "Files Changed");
+    const report = {
+      uuid: uuidRaw ?? randomUUID4(),
+      ...displayIdRaw ? { displayId: displayIdRaw } : {},
+      ...createdAtRaw ? { createdAt: createdAtRaw } : {},
+      taskId,
+      taskName: headingMatch[1].trim(),
+      date: headingMatch[2].trim(),
+      sprint: parseInt(headingMatch[3], 10),
+      completed: completedRaw.startsWith("Yes") ? "Yes" : completedRaw.startsWith("No") ? "No" : "Partial",
+      actualEffort,
+      estimatedEffort,
+      surprises: parseField(block, "Surprises"),
+      discoveredIssues: parseField(block, "Discovered Issues"),
+      architectureNotes: parseField(block, "Architecture Notes"),
+      scopeAccuracy
+    };
+    if (commitShaRaw) report.commitSha = commitShaRaw;
+    if (filesChangedRaw) report.filesChanged = filesChangedRaw.split(",").map((f) => f.trim()).filter(Boolean);
+    return report;
+  }).filter((r) => r !== null);
+}
+function serializeBuildReport(report) {
+  const lines = [
+    `### ${report.taskName} \u2014 ${report.date} \u2014 Sprint ${report.sprint}`
+  ];
+  if (report.uuid) lines.push(`- **UUID:** ${report.uuid}`);
+  if (report.displayId) lines.push(`- **Display ID:** ${report.displayId}`);
+  if (report.createdAt) lines.push(`- **Created:** ${report.createdAt}`);
+  lines.push(
+    `- **Task ID:** ${report.taskId}`,
+    `- **Completed:** ${report.completed}`,
+    `- **Actual Effort:** ${report.actualEffort} vs estimated ${report.estimatedEffort}`,
+    `- **Surprises:** ${report.surprises || "None"}`,
+    `- **Discovered Issues:** ${report.discoveredIssues || "None"}`,
+    `- **Architecture Notes:** ${report.architectureNotes || "None"}`,
+    `- **Scope Accuracy:** ${report.scopeAccuracy}`
+  );
+  if (report.commitSha) lines.push(`- **Commit SHA:** ${report.commitSha}`);
+  if (report.filesChanged && report.filesChanged.length > 0) {
+    lines.push(`- **Files Changed:** ${report.filesChanged.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function formatCompressedSummary(reports, sprintRange, aiSummary) {
+  const dates = reports.map((r) => r.date).filter(Boolean);
+  const dateRange = dates.length > 0 ? `${dates[dates.length - 1]} \u2013 ${dates[0]}` : "unknown";
+  const completed = reports.filter((r) => r.completed === "Yes");
+  const partial = reports.filter((r) => r.completed === "Partial");
+  const failed = reports.filter((r) => r.completed === "No");
+  const formatTaskList = (list) => list.map((r) => r.taskId !== "unknown" ? `${r.taskId} (${r.taskName})` : r.taskName).join(", ");
+  const lines = [`### ${sprintRange} \u2014 Compressed Summary`];
+  lines.push(`**Date range:** ${dateRange}`);
+  lines.push(`**Reports:** ${reports.length}`);
+  if (completed.length > 0) {
+    lines.push(`**Completed:** ${formatTaskList(completed)}`);
+  }
+  if (partial.length > 0) {
+    lines.push(`**Partial:** ${formatTaskList(partial)}`);
+  }
+  if (failed.length > 0) {
+    lines.push(`**Failed:** ${formatTaskList(failed)}`);
+  }
+  const surprises = reports.map((r) => r.surprises).filter((s) => s && s !== "None" && s !== "None.");
+  if (surprises.length > 0) {
+    lines.push(`**Surprises:** ${surprises.join("; ")}`);
+  }
+  const issues = reports.map((r) => r.discoveredIssues).filter((s) => s && s !== "None" && s !== "None.");
+  if (issues.length > 0) {
+    lines.push(`**Discovered issues:** ${issues.join("; ")}`);
+  }
+  if (aiSummary) {
+    lines.push(`**Key outcomes:** ${aiSummary}`);
+  }
+  return lines.join("\n");
+}
+function compressBuildReportsInContent(content, threshold, summary) {
+  const chunks = content.split(/^(?=### .+ — .+ — (?:Sprint|Session) \d+)/m).map((c) => c.trim()).filter((c) => c.match(/^### .+ — .+ — (?:Sprint|Session) \d+/));
+  const keep = [];
+  const oldChunks = [];
+  for (const block of chunks) {
+    const match = block.match(/— (?:Sprint|Session) (\d+)/);
+    const num = match ? parseInt(match[1], 10) : 0;
+    if (num >= threshold) {
+      keep.push(block);
+    } else {
+      oldChunks.push(block);
+    }
+  }
+  if (oldChunks.length === 0) return content;
+  const oldReports = parseBuildReports(oldChunks.join("\n\n---\n\n"));
+  const sprintRange = `Sprints 1\u2013${threshold - 1}`;
+  const summaryBlock = formatCompressedSummary(oldReports, sprintRange, summary);
+  const firstReportIdx = content.search(/^### /m);
+  const header = firstReportIdx === -1 ? content : content.slice(0, firstReportIdx);
+  const entries = [...keep, summaryBlock].join("\n\n---\n\n");
+  return header + entries + "\n";
+}
+function mergeTextField(existing, incoming) {
+  if (!existing || existing === "None" || existing === "None.") return incoming;
+  if (!incoming || incoming === "None" || incoming === "None.") return existing;
+  if (existing === incoming) return existing;
+  return `${existing} | ${incoming}`;
+}
+function mergeBuildReports(existing, incoming) {
+  const uuid = incoming.uuid ?? existing.uuid;
+  const displayId = incoming.displayId ?? existing.displayId;
+  const merged = {
+    uuid,
+    ...displayId ? { displayId } : {},
+    taskId: incoming.taskId,
+    taskName: incoming.taskName,
+    date: incoming.date,
+    sprint: incoming.sprint,
+    completed: incoming.completed,
+    actualEffort: incoming.actualEffort,
+    estimatedEffort: incoming.estimatedEffort,
+    surprises: mergeTextField(existing.surprises, incoming.surprises),
+    discoveredIssues: mergeTextField(existing.discoveredIssues, incoming.discoveredIssues),
+    architectureNotes: incoming.architectureNotes,
+    scopeAccuracy: incoming.scopeAccuracy
+  };
+  if (incoming.createdAt ?? existing.createdAt) merged.createdAt = incoming.createdAt ?? existing.createdAt;
+  if (incoming.commitSha ?? existing.commitSha) merged.commitSha = incoming.commitSha ?? existing.commitSha;
+  if (incoming.filesChanged ?? existing.filesChanged) merged.filesChanged = incoming.filesChanged ?? existing.filesChanged;
+  return merged;
+}
+function replaceBuildReport(existing, replacement, content) {
+  const oldSerialized = serializeBuildReport(existing);
+  const newSerialized = serializeBuildReport(replacement);
+  const idx = content.indexOf(oldSerialized);
+  if (idx !== -1) {
+    return content.slice(0, idx) + newSerialized + content.slice(idx + oldSerialized.length);
+  }
+  const headingPattern = `### ${existing.taskName} \u2014 ${existing.date} \u2014 Sprint ${existing.sprint}`;
+  const headingIdx = content.indexOf(headingPattern);
+  if (headingIdx === -1) throw new Error(`Could not find existing build report for ${existing.taskId}`);
+  const afterHeading = content.slice(headingIdx);
+  const nextSeparator = afterHeading.indexOf("\n\n---\n");
+  const blockEnd = nextSeparator === -1 ? content.length : headingIdx + nextSeparator;
+  return content.slice(0, headingIdx) + newSerialized + content.slice(blockEnd);
+}
+function prependBuildReport(report, content) {
+  if (report.taskId !== "unknown") {
+    const existingReports = parseBuildReports(content);
+    const existingReport = existingReports.find((r) => r.taskId === report.taskId);
+    if (existingReport) {
+      const merged = mergeBuildReports(existingReport, report);
+      return replaceBuildReport(existingReport, merged, content);
+    }
+  }
+  const sentinelIdx = content.indexOf(HEADER_SENTINEL);
+  if (sentinelIdx === -1) throw new Error("Build Reports header sentinel not found");
+  const afterSentinel = content.slice(sentinelIdx);
+  const separatorIdx = afterSentinel.indexOf("\n---\n");
+  if (separatorIdx === -1) throw new Error("Separator after Build Reports header not found");
+  const insertAt = sentinelIdx + separatorIdx + "\n---\n".length;
+  const serialized = serializeBuildReport(report);
+  return content.slice(0, insertAt) + "\n" + serialized + "\n\n---\n" + content.slice(insertAt);
+}
+
+// src/parsers/metrics.ts
+var TABLE_HEADER = "| Timestamp | Tool | Duration (ms) | Input Tokens | Output Tokens | Cost ($) | Model | Sprint | Context |";
+var TABLE_SEPARATOR = "|-----------|------|---------------|--------------|---------------|----------|-------|--------|---------|";
+var PREV_TABLE_HEADER = "| Timestamp | Tool | Duration (ms) | Input Tokens | Output Tokens | Cost ($) | Model | Sprint |";
+var LEGACY_TABLE_HEADER = "| Timestamp | Tool | Duration (ms) | Input Tokens | Output Tokens | Cost ($) | Model |";
+var SECTION_HEADING = "## Tool Call Metrics";
+var FILE_TEMPLATE = `# PAPI Metrics
+
+${SECTION_HEADING}
+
+${TABLE_HEADER}
+${TABLE_SEPARATOR}
+`;
+function parseToolMetrics(content) {
+  const lines = content.split("\n");
+  const metrics = [];
+  let inSection = false;
+  let inTable = false;
+  for (const line of lines) {
+    if (line.startsWith(SECTION_HEADING)) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && line.startsWith(COST_SECTION_HEADING)) {
+      break;
+    }
+    if (!inSection) continue;
+    if (line.startsWith(TABLE_SEPARATOR) || line.startsWith("|---")) {
+      inTable = true;
+      continue;
+    }
+    if (!inTable) continue;
+    if (!line.startsWith("|")) {
+      inTable = false;
+      continue;
+    }
+    const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
+    if (cells.length < 7) continue;
+    const inputTokens = cells[3] !== "-" ? parseInt(cells[3].replace(/,/g, ""), 10) : void 0;
+    const outputTokens = cells[4] !== "-" ? parseInt(cells[4].replace(/,/g, ""), 10) : void 0;
+    const cost = cells[5] !== "-" ? parseFloat(cells[5]) : void 0;
+    const model = cells[6] !== "-" ? cells[6] : void 0;
+    const sprintRaw = cells.length >= 8 && cells[7] !== "-" ? parseInt(cells[7], 10) : void 0;
+    const sprintNumber = sprintRaw !== void 0 && !isNaN(sprintRaw) ? sprintRaw : void 0;
+    const contextRaw = cells.length >= 9 && cells[8] !== "-" ? parseInt(cells[8].replace(/,/g, ""), 10) : void 0;
+    const contextBytes = contextRaw !== void 0 && !isNaN(contextRaw) ? contextRaw : void 0;
+    const utilisationRaw = cells.length >= 10 && cells[9] !== "-" ? parseFloat(cells[9]) : void 0;
+    const contextUtilisation = utilisationRaw !== void 0 && !isNaN(utilisationRaw) ? utilisationRaw : void 0;
+    metrics.push({
+      timestamp: cells[0],
+      tool: cells[1],
+      durationMs: parseInt(cells[2].replace(/,/g, ""), 10),
+      ...inputTokens !== void 0 && !isNaN(inputTokens) ? { inputTokens } : {},
+      ...outputTokens !== void 0 && !isNaN(outputTokens) ? { outputTokens } : {},
+      ...cost !== void 0 && !isNaN(cost) ? { estimatedCostUsd: cost } : {},
+      ...model ? { model } : {},
+      ...sprintNumber !== void 0 ? { sprintNumber } : {},
+      ...contextBytes !== void 0 ? { contextBytes } : {},
+      ...contextUtilisation !== void 0 ? { contextUtilisation } : {}
+    });
+  }
+  return metrics;
+}
+function formatNumber(n) {
+  return n.toLocaleString("en-US");
+}
+function serializeToolMetric(metric) {
+  const inputTokens = metric.inputTokens !== void 0 ? formatNumber(metric.inputTokens) : "-";
+  const outputTokens = metric.outputTokens !== void 0 ? formatNumber(metric.outputTokens) : "-";
+  const cost = metric.estimatedCostUsd !== void 0 ? metric.estimatedCostUsd.toFixed(4) : "-";
+  const model = metric.model ?? "-";
+  const sprint = metric.sprintNumber !== void 0 ? String(metric.sprintNumber) : "-";
+  const context = metric.contextBytes !== void 0 ? formatNumber(metric.contextBytes) : "-";
+  const utilisation = metric.contextUtilisation !== void 0 ? metric.contextUtilisation.toFixed(2) : "-";
+  return `| ${metric.timestamp} | ${metric.tool} | ${formatNumber(metric.durationMs)} | ${inputTokens} | ${outputTokens} | ${cost} | ${model} | ${sprint} | ${context} | ${utilisation} |`;
+}
+function appendToolMetricToContent(metric, content) {
+  if (!content.trim()) {
+    return FILE_TEMPLATE + serializeToolMetric(metric) + "\n";
+  }
+  if (content.includes(LEGACY_TABLE_HEADER) && !content.includes(TABLE_HEADER)) {
+    content = content.replace(LEGACY_TABLE_HEADER, TABLE_HEADER);
+    content = content.replace(
+      /\|[-]+\|[-]+\|[-]+\|[-]+\|[-]+\|[-]+\|[-]+\|/,
+      TABLE_SEPARATOR
+    );
+  }
+  if (content.includes(PREV_TABLE_HEADER) && !content.includes(TABLE_HEADER)) {
+    content = content.replace(PREV_TABLE_HEADER, TABLE_HEADER);
+    content = content.replace(
+      /\|[-]+\|[-]+\|[-]+\|[-]+\|[-]+\|[-]+\|[-]+\|[-]+\|/,
+      TABLE_SEPARATOR
+    );
+  }
+  if (!content.includes(SECTION_HEADING)) {
+    return content.trimEnd() + "\n\n" + SECTION_HEADING + "\n\n" + TABLE_HEADER + "\n" + TABLE_SEPARATOR + "\n" + serializeToolMetric(metric) + "\n";
+  }
+  const costIdx = content.indexOf(COST_SECTION_HEADING);
+  if (costIdx === -1) {
+    return content.trimEnd() + "\n" + serializeToolMetric(metric) + "\n";
+  }
+  const before = content.slice(0, costIdx).trimEnd();
+  const after = content.slice(costIdx);
+  return before + "\n" + serializeToolMetric(metric) + "\n\n" + after;
+}
+function aggregateCostSummary(metrics, sprintNumber) {
+  const filtered = sprintNumber !== void 0 ? metrics.filter((m) => m.sprintNumber === sprintNumber) : metrics;
+  let totalCostUsd = 0;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  const byCommand = /* @__PURE__ */ new Map();
+  for (const m of filtered) {
+    totalCostUsd += m.estimatedCostUsd ?? 0;
+    totalInputTokens += m.inputTokens ?? 0;
+    totalOutputTokens += m.outputTokens ?? 0;
+    const entry = byCommand.get(m.tool) ?? { cost: 0, calls: 0 };
+    entry.cost += m.estimatedCostUsd ?? 0;
+    entry.calls += 1;
+    byCommand.set(m.tool, entry);
+  }
+  const costByCommand = Array.from(byCommand.entries()).map(([command, { cost, calls }]) => ({
+    command,
+    totalCostUsd: cost,
+    calls,
+    avgCostUsd: calls > 0 ? cost / calls : 0
+  })).sort((a, b) => b.totalCostUsd - a.totalCostUsd);
+  const mostExpensiveCommand = costByCommand.length > 0 ? costByCommand[0].command : null;
+  return {
+    totalCostUsd,
+    totalInputTokens,
+    totalOutputTokens,
+    totalCalls: filtered.length,
+    costByCommand,
+    mostExpensiveCommand,
+    avgCostPerCall: filtered.length > 0 ? totalCostUsd / filtered.length : 0
+  };
+}
+var COST_SECTION_HEADING = "## Cost Summary";
+var COST_TABLE_HEADER = "| Sprint | Date | Total Cost ($) | Input Tokens | Output Tokens | Calls |";
+var COST_TABLE_SEPARATOR = "|--------|------|----------------|--------------|---------------|-------|";
+function parseCostSnapshots(content) {
+  const lines = content.split("\n");
+  const snapshots = [];
+  let inTable = false;
+  for (const line of lines) {
+    if (line.startsWith(COST_TABLE_SEPARATOR)) {
+      inTable = true;
+      continue;
+    }
+    if (!inTable) continue;
+    if (!line.startsWith("|")) {
+      inTable = false;
+      continue;
+    }
+    const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
+    if (cells.length < 6) continue;
+    snapshots.push({
+      sprint: parseInt(cells[0], 10),
+      date: cells[1],
+      totalCostUsd: parseFloat(cells[2]),
+      totalInputTokens: parseInt(cells[3].replace(/,/g, ""), 10),
+      totalOutputTokens: parseInt(cells[4].replace(/,/g, ""), 10),
+      totalCalls: parseInt(cells[5].replace(/,/g, ""), 10)
+    });
+  }
+  return snapshots;
+}
+function serializeCostSnapshot(snapshot) {
+  return `| ${snapshot.sprint} | ${snapshot.date} | ${snapshot.totalCostUsd.toFixed(4)} | ${formatNumber(snapshot.totalInputTokens)} | ${formatNumber(snapshot.totalOutputTokens)} | ${formatNumber(snapshot.totalCalls)} |`;
+}
+function writeCostSnapshotToContent(snapshot, content) {
+  if (!content.includes(COST_SECTION_HEADING)) {
+    return content.trimEnd() + "\n\n" + COST_SECTION_HEADING + "\n\n" + COST_TABLE_HEADER + "\n" + COST_TABLE_SEPARATOR + "\n" + serializeCostSnapshot(snapshot) + "\n";
+  }
+  const lines = content.split("\n");
+  const sprintPrefix = `| ${snapshot.sprint} |`;
+  let replaced = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith(sprintPrefix)) {
+      lines[i] = serializeCostSnapshot(snapshot);
+      replaced = true;
+      break;
+    }
+  }
+  if (replaced) {
+    return lines.join("\n");
+  }
+  return content.trimEnd() + "\n" + serializeCostSnapshot(snapshot) + "\n";
+}
+
+// src/parsers/sprint-metrics.ts
+var FILE_HEADING = "# Sprint Methodology Metrics";
+var ACCURACY_HEADER = "| Sprint | Reports | Match Rate | MAE | Bias |";
+var ACCURACY_SEPARATOR = "|--------|---------|------------|-----|------|";
+var VELOCITY_HEADER = "| Sprint | Completed | Partial | Failed | Effort Points |";
+var VELOCITY_SEPARATOR = "|--------|-----------|---------|--------|---------------|";
+var EFFORT_SCALE = {
+  XS: 1,
+  S: 2,
+  M: 3,
+  L: 4,
+  XL: 5
+};
+function effortOrdinal(effort) {
+  const normalized = effort.trim().toUpperCase();
+  return EFFORT_SCALE[normalized];
+}
+function calculateSprintMetrics(reports, currentSprint, window = 5) {
+  const recentReports = reports.filter(
+    (r) => r.sprint > currentSprint - window && r.sprint <= currentSprint
+  );
+  const perSprint = /* @__PURE__ */ new Map();
+  for (const r of recentReports) {
+    const group = perSprint.get(r.sprint) ?? [];
+    group.push(r);
+    perSprint.set(r.sprint, group);
+  }
+  const accuracy = [];
+  const velocity = [];
+  const sortedSprints = [...perSprint.keys()].sort((a, b) => a - b);
+  for (const sprint of sortedSprints) {
+    const reps = perSprint.get(sprint);
+    const deltas = [];
+    for (const r of reps) {
+      const actual = effortOrdinal(r.actualEffort);
+      const estimated = effortOrdinal(r.estimatedEffort);
+      if (actual !== void 0 && estimated !== void 0) {
+        deltas.push(actual - estimated);
+      }
+    }
+    if (deltas.length > 0) {
+      accuracy.push({
+        sprint,
+        reports: deltas.length,
+        matchRate: Math.round(deltas.filter((d) => d === 0).length / deltas.length * 100),
+        mae: Math.round(deltas.reduce((s, d) => s + Math.abs(d), 0) / deltas.length * 10) / 10,
+        bias: Math.round(deltas.reduce((s, d) => s + d, 0) / deltas.length * 10) / 10
+      });
+    }
+    velocity.push({
+      sprint,
+      completed: reps.filter((r) => r.completed === "Yes").length,
+      partial: reps.filter((r) => r.completed === "Partial").length,
+      failed: reps.filter((r) => r.completed === "No").length,
+      effortPoints: reps.reduce((s, r) => s + (effortOrdinal(r.actualEffort) ?? 0), 0)
+    });
+  }
+  return { accuracy, velocity };
+}
+function serializeAccuracyRow(a) {
+  return `| ${a.sprint} | ${a.reports} | ${a.matchRate}% | ${a.mae} | ${a.bias >= 0 ? "+" : ""}${a.bias} |`;
+}
+function serializeVelocityRow(v) {
+  return `| ${v.sprint} | ${v.completed} | ${v.partial} | ${v.failed} | ${v.effortPoints} |`;
+}
+function serializeSnapshot(snapshot) {
+  const lines = [];
+  lines.push(`## Sprint ${snapshot.sprint} Snapshot \u2014 ${snapshot.date}`);
+  lines.push("");
+  lines.push("### Estimation Accuracy (last 5 sprints)");
+  lines.push(ACCURACY_HEADER);
+  lines.push(ACCURACY_SEPARATOR);
+  for (const a of snapshot.accuracy) {
+    lines.push(serializeAccuracyRow(a));
+  }
+  lines.push("");
+  lines.push("### Sprint Velocity");
+  lines.push(VELOCITY_HEADER);
+  lines.push(VELOCITY_SEPARATOR);
+  for (const v of snapshot.velocity) {
+    lines.push(serializeVelocityRow(v));
+  }
+  return lines.join("\n");
+}
+function appendSnapshotToContent(snapshot, content) {
+  const block = serializeSnapshot(snapshot);
+  if (!content.trim()) {
+    return FILE_HEADING + "\n\n" + block + "\n";
+  }
+  const marker = `## Sprint ${snapshot.sprint} Snapshot`;
+  const markerIdx = content.indexOf(marker);
+  if (markerIdx !== -1) {
+    const nextSnapshotIdx = content.indexOf("\n## Sprint ", markerIdx + marker.length);
+    const before = content.slice(0, markerIdx).trimEnd();
+    const after = nextSnapshotIdx !== -1 ? content.slice(nextSnapshotIdx) : "";
+    return before + "\n\n" + block + (after ? after : "\n");
+  }
+  return content.trimEnd() + "\n\n" + block + "\n";
+}
+function parseSnapshots(content) {
+  if (!content.trim()) return [];
+  const snapshots = [];
+  const headerRegex = /^## Sprint (\d+) Snapshot — (\S+)/gm;
+  let match;
+  const headers = [];
+  while ((match = headerRegex.exec(content)) !== null) {
+    headers.push({
+      sprint: parseInt(match[1], 10),
+      date: match[2],
+      index: match.index
+    });
+  }
+  for (let i = 0; i < headers.length; i++) {
+    const start = headers[i].index;
+    const end = i + 1 < headers.length ? headers[i + 1].index : content.length;
+    const block = content.slice(start, end);
+    const accuracy = parseAccuracyTable(block);
+    const velocity = parseVelocityTable(block);
+    snapshots.push({
+      sprint: headers[i].sprint,
+      date: headers[i].date,
+      accuracy,
+      velocity
+    });
+  }
+  return snapshots;
+}
+var NONE_PATTERN = /^none\b/i;
+function normalizeText(text) {
+  return text.trim().toLowerCase().replace(/[.,;:!]+$/, "").replace(/\s+/g, " ");
+}
+function isRealFinding(text) {
+  const trimmed = text.trim();
+  return trimmed.length > 0 && !NONE_PATTERN.test(trimmed);
+}
+async function detectBuildPatterns(reports, currentSprint, window = 5, clusterer) {
+  const recentReports = reports.filter(
+    (r) => r.sprint > currentSprint - window && r.sprint <= currentSprint
+  );
+  let recurringSurprises;
+  const realSurprises = recentReports.filter((r) => isRealFinding(r.surprises));
+  if (clusterer && realSurprises.length >= 2) {
+    const entries = realSurprises.map((r) => ({
+      text: r.surprises.trim(),
+      source: String(r.sprint)
+    }));
+    const clusters = await clusterer(entries);
+    recurringSurprises = clusters.filter((c) => c.entries.length >= 2).map((c) => ({
+      text: c.theme,
+      count: c.entries.length,
+      sprints: [...new Set(c.entries.map((e) => parseInt(e.source, 10)))].sort((a, b) => a - b)
+    }));
+    recurringSurprises.sort((a, b) => b.count - a.count);
+  } else {
+    const surpriseMap = /* @__PURE__ */ new Map();
+    for (const r of realSurprises) {
+      const key = normalizeText(r.surprises);
+      const existing = surpriseMap.get(key);
+      if (existing) {
+        existing.count += 1;
+        existing.sprints.add(r.sprint);
+      } else {
+        surpriseMap.set(key, { original: r.surprises.trim(), count: 1, sprints: /* @__PURE__ */ new Set([r.sprint]) });
+      }
+    }
+    recurringSurprises = [];
+    for (const entry of surpriseMap.values()) {
+      if (entry.count >= 2) {
+        recurringSurprises.push({
+          text: entry.original,
+          count: entry.count,
+          sprints: [...entry.sprints].sort((a, b) => a - b)
+        });
+      }
+    }
+    recurringSurprises.sort((a, b) => b.count - a.count);
+  }
+  let overCount = 0;
+  let underCount = 0;
+  let totalWithEffort = 0;
+  for (const r of recentReports) {
+    const actual = effortOrdinal(r.actualEffort);
+    const estimated = effortOrdinal(r.estimatedEffort);
+    if (actual === void 0 || estimated === void 0) continue;
+    totalWithEffort += 1;
+    if (actual > estimated) underCount += 1;
+    if (actual < estimated) overCount += 1;
+  }
+  let estimationBias = "none";
+  let estimationBiasRate = 0;
+  if (totalWithEffort > 0) {
+    const underRate = underCount / totalWithEffort;
+    const overRate = overCount / totalWithEffort;
+    if (underRate >= 0.5) {
+      estimationBias = "under";
+      estimationBiasRate = Math.round(underRate * 100);
+    } else if (overRate >= 0.5) {
+      estimationBias = "over";
+      estimationBiasRate = Math.round(overRate * 100);
+    }
+  }
+  const scopeAccuracyBreakdown = {};
+  for (const r of recentReports) {
+    if (r.scopeAccuracy) {
+      scopeAccuracyBreakdown[r.scopeAccuracy] = (scopeAccuracyBreakdown[r.scopeAccuracy] ?? 0) + 1;
+    }
+  }
+  const untriagedIssues = [];
+  for (const r of recentReports) {
+    if (isRealFinding(r.discoveredIssues)) {
+      untriagedIssues.push(r.discoveredIssues.trim());
+    }
+  }
+  return {
+    recurringSurprises,
+    estimationBias,
+    estimationBiasRate,
+    scopeAccuracyBreakdown,
+    untriagedIssues
+  };
+}
+function hasBuildPatterns(patterns) {
+  return patterns.recurringSurprises.length > 0 || patterns.estimationBias !== "none" || patterns.untriagedIssues.length > 0;
+}
+function parseAccuracyTable(block) {
+  const rows = [];
+  const lines = block.split("\n");
+  let inTable = false;
+  for (const line of lines) {
+    if (line.startsWith(ACCURACY_SEPARATOR)) {
+      inTable = true;
+      continue;
+    }
+    if (!inTable) continue;
+    if (!line.startsWith("|")) {
+      inTable = false;
+      continue;
+    }
+    const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
+    if (cells.length < 5) continue;
+    rows.push({
+      sprint: parseInt(cells[0], 10),
+      reports: parseInt(cells[1], 10),
+      matchRate: parseInt(cells[2].replace("%", ""), 10),
+      mae: parseFloat(cells[3]),
+      bias: parseFloat(cells[4])
+    });
+  }
+  return rows;
+}
+function parseVelocityTable(block) {
+  const rows = [];
+  const lines = block.split("\n");
+  let inTable = false;
+  for (const line of lines) {
+    if (line.startsWith(VELOCITY_SEPARATOR)) {
+      inTable = true;
+      continue;
+    }
+    if (!inTable) continue;
+    if (!line.startsWith("|")) {
+      inTable = false;
+      continue;
+    }
+    const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
+    if (cells.length < 5) continue;
+    rows.push({
+      sprint: parseInt(cells[0], 10),
+      completed: parseInt(cells[1], 10),
+      partial: parseInt(cells[2], 10),
+      failed: parseInt(cells[3], 10),
+      effortPoints: parseInt(cells[4], 10)
+    });
+  }
+  return rows;
+}
+
+// src/parsers/reviews.ts
+import { randomUUID as randomUUID5 } from "crypto";
+var HEADER_SENTINEL2 = "*Reviews are stored newest-first.";
+var VALID_STAGES = /* @__PURE__ */ new Set(["handoff-review", "build-acceptance"]);
+var VALID_VERDICTS = /* @__PURE__ */ new Set(["approve", "accept", "request-changes", "reject"]);
+function parseField2(block, field) {
+  const pattern = new RegExp(`^- \\*\\*${field}:\\*\\*\\s*(.+)$`, "m");
+  const match = block.match(pattern);
+  return match ? match[1].trim() : "";
+}
+function parseReviews(content) {
+  if (!content.trim()) return [];
+  const chunks = content.split(/^(?=### task-\S+ — .+ — \d{4}-\d{2}-\d{2})/m).map((c) => c.trim()).filter((c) => c.match(/^### task-\S+ — .+ — \d{4}-\d{2}-\d{2}/));
+  return chunks.map((block) => {
+    const headingMatch = block.match(/^### (task-\S+) — (.+?) — (\d{4}-\d{2}-\d{2}[T\d:.Z]*)/);
+    if (!headingMatch) return null;
+    const taskId = headingMatch[1];
+    const stageRaw = headingMatch[2].trim();
+    const date = headingMatch[3];
+    const stage = stageRaw.toLowerCase().replace(/\s+/g, "-");
+    if (!VALID_STAGES.has(stage)) return null;
+    const reviewer = parseField2(block, "Reviewer");
+    const verdictRaw = parseField2(block, "Verdict");
+    if (!VALID_VERDICTS.has(verdictRaw)) return null;
+    const verdict = verdictRaw;
+    const sprint = parseInt(parseField2(block, "Sprint"), 10);
+    if (isNaN(sprint)) return null;
+    const comments = parseField2(block, "Comments");
+    const uuidRaw = parseField2(block, "UUID");
+    const displayIdRaw = parseField2(block, "Display ID");
+    const review = { uuid: uuidRaw ?? randomUUID5(), ...displayIdRaw ? { displayId: displayIdRaw } : {}, taskId, stage, reviewer, verdict, sprint, date, comments };
+    const handoffRevRaw = parseField2(block, "Handoff Revision");
+    if (handoffRevRaw) {
+      const parsed = parseInt(handoffRevRaw, 10);
+      if (!isNaN(parsed)) review.handoffRevision = parsed;
+    }
+    const buildCommitSha = parseField2(block, "Build Commit SHA");
+    if (buildCommitSha) review.buildCommitSha = buildCommitSha;
+    return review;
+  }).filter((r) => r !== null);
+}
+var STAGE_DISPLAY = {
+  "handoff-review": "Handoff Review",
+  "build-acceptance": "Build Acceptance"
+};
+function serializeReview(review) {
+  const stageDisplay = STAGE_DISPLAY[review.stage];
+  const lines = [
+    `### ${review.taskId} \u2014 ${stageDisplay} \u2014 ${review.date}`,
+    ""
+  ];
+  if (review.uuid) lines.push(`- **UUID:** ${review.uuid}`);
+  if (review.displayId) lines.push(`- **Display ID:** ${review.displayId}`);
+  lines.push(
+    `- **Reviewer:** ${review.reviewer}`,
+    `- **Verdict:** ${review.verdict}`,
+    `- **Sprint:** ${review.sprint}`,
+    `- **Comments:** ${review.comments}`
+  );
+  if (review.handoffRevision !== void 0) lines.push(`- **Handoff Revision:** ${review.handoffRevision}`);
+  if (review.buildCommitSha) lines.push(`- **Build Commit SHA:** ${review.buildCommitSha}`);
+  return lines.join("\n");
+}
+function prependReview(review, content) {
+  const serialized = serializeReview(review);
+  if (!content.trim()) {
+    return `# Human Reviews
+
+${HEADER_SENTINEL2} Each review block references a task and stage.*
+
+---
+
+${serialized}
+`;
+  }
+  const sentinelIdx = content.indexOf(HEADER_SENTINEL2);
+  if (sentinelIdx === -1) {
+    const firstSep = content.indexOf("\n---\n");
+    if (firstSep === -1) return content.trimEnd() + "\n\n---\n\n" + serialized + "\n";
+    const insertAt2 = firstSep + "\n---\n".length;
+    return content.slice(0, insertAt2) + "\n" + serialized + "\n\n---\n" + content.slice(insertAt2);
+  }
+  const afterSentinel = content.slice(sentinelIdx);
+  const separatorIdx = afterSentinel.indexOf("\n---\n");
+  if (separatorIdx === -1) {
+    return content.trimEnd() + "\n\n---\n\n" + serialized + "\n";
+  }
+  const insertAt = sentinelIdx + separatorIdx + "\n---\n".length;
+  return content.slice(0, insertAt) + "\n" + serialized + "\n\n---\n" + content.slice(insertAt);
+}
+
+// src/parsers/phases.ts
+var VALID_STATUSES = /* @__PURE__ */ new Set(["Not Started", "In Progress", "Done", "Deferred"]);
+var PHASES_START = "<!-- PHASES:START -->";
+var PHASES_END = "<!-- PHASES:END -->";
+function parsePhases(content) {
+  const startIdx = content.indexOf(PHASES_START);
+  const endIdx = content.indexOf(PHASES_END);
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) return [];
+  const section = content.slice(startIdx + PHASES_START.length, endIdx);
+  const yamlMatch = section.match(/```yaml\s*\n([\s\S]*?)```/);
+  if (!yamlMatch) return [];
+  const yamlBody = yamlMatch[1];
+  const phases = [];
+  const blocks = yamlBody.split(/^(?=\s*- id:)/m).filter((b) => b.trim());
+  for (const block of blocks) {
+    const phase = parsePhaseBlock(block);
+    if (phase) phases.push(phase);
+  }
+  return phases.sort((a, b) => a.order - b.order);
+}
+function parseYamlField(block, field) {
+  const pattern = new RegExp(`^\\s*${field}:\\s*(.+)$`, "m");
+  const match = block.match(pattern);
+  if (!match) return "";
+  let value = match[1].trim();
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    value = value.slice(1, -1);
+  }
+  return value;
+}
+function parsePhaseBlock(block) {
+  const idMatch = block.match(/^\s*- id:\s*(\S+)/m);
+  if (!idMatch) return null;
+  const id = idMatch[1];
+  const slug = parseYamlField(block, "slug");
+  const label = parseYamlField(block, "label");
+  const description = parseYamlField(block, "description");
+  const statusRaw = parseYamlField(block, "status");
+  const orderRaw = parseYamlField(block, "order");
+  if (!slug || !label || !statusRaw || !orderRaw) return null;
+  const status = statusRaw;
+  if (!VALID_STATUSES.has(status)) return null;
+  const order = parseInt(orderRaw, 10);
+  if (isNaN(order)) return null;
+  return { id, slug, label, description, status, order };
+}
+function serializePhases(phases) {
+  const sorted = [...phases].sort((a, b) => a.order - b.order);
+  const yamlLines = ["phases:"];
+  for (const p of sorted) {
+    yamlLines.push(`  - id: ${p.id}`);
+    yamlLines.push(`    slug: "${p.slug}"`);
+    yamlLines.push(`    label: "${p.label}"`);
+    yamlLines.push(`    description: "${p.description}"`);
+    yamlLines.push(`    status: "${p.status}"`);
+    yamlLines.push(`    order: ${p.order}`);
+  }
+  return yamlLines.join("\n");
+}
+function writePhasesToContent(phases, content) {
+  const yaml4 = serializePhases(phases);
+  const newSection = `${PHASES_START}
+
+\`\`\`yaml
+${yaml4}
+\`\`\`
+
+${PHASES_END}`;
+  const startIdx = content.indexOf(PHASES_START);
+  const endIdx = content.indexOf(PHASES_END);
+  if (startIdx !== -1 && endIdx !== -1) {
+    return content.slice(0, startIdx) + newSection + content.slice(endIdx + PHASES_END.length);
+  }
+  return content.trimEnd() + "\n\n" + newSection + "\n";
+}
+
+// src/parsers/features.ts
+var VALID_STATUSES2 = /* @__PURE__ */ new Set(["Not Started", "In Progress", "Done", "Deferred"]);
+var FEATURES_START = "<!-- FEATURES:START -->";
+var FEATURES_END = "<!-- FEATURES:END -->";
+function parseFeatures(content) {
+  const startIdx = content.indexOf(FEATURES_START);
+  const endIdx = content.indexOf(FEATURES_END);
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) return [];
+  const section = content.slice(startIdx + FEATURES_START.length, endIdx);
+  const yamlMatch = section.match(/```yaml\s*\n([\s\S]*?)```/);
+  if (!yamlMatch) return [];
+  const yamlBody = yamlMatch[1];
+  const features = [];
+  const blocks = yamlBody.split(/^(?=\s*- id:)/m).filter((b) => b.trim());
+  for (const block of blocks) {
+    const feature = parseFeatureBlock(block);
+    if (feature) features.push(feature);
+  }
+  return features.sort((a, b) => a.roadmapPosition - b.roadmapPosition);
+}
+function parseYamlField2(block, field) {
+  const pattern = new RegExp(`^\\s*${field}:\\s*(.+)$`, "m");
+  const match = block.match(pattern);
+  if (!match) return "";
+  let value = match[1].trim();
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    value = value.slice(1, -1);
+  }
+  return value;
+}
+function parseOptionalYamlField(block, field) {
+  const value = parseYamlField2(block, field);
+  return value || void 0;
+}
+function parseFeatureBlock(block) {
+  const idMatch = block.match(/^\s*- id:\s*(.+)$/m);
+  if (!idMatch) return null;
+  let id = idMatch[1].trim();
+  if (id.startsWith('"') && id.endsWith('"') || id.startsWith("'") && id.endsWith("'")) {
+    id = id.slice(1, -1);
+  }
+  const displayId = parseYamlField2(block, "displayId");
+  const slug = parseYamlField2(block, "slug");
+  const name = parseYamlField2(block, "name");
+  const description = parseYamlField2(block, "description");
+  const statusRaw = parseYamlField2(block, "status");
+  const roadmapPositionRaw = parseYamlField2(block, "roadmapPosition");
+  const createdAt = parseYamlField2(block, "createdAt");
+  const createdSprintRaw = parseYamlField2(block, "createdSprint");
+  if (!displayId || !slug || !name || !statusRaw || !roadmapPositionRaw || !createdAt || !createdSprintRaw) return null;
+  const status = statusRaw;
+  if (!VALID_STATUSES2.has(status)) return null;
+  const roadmapPosition = parseInt(roadmapPositionRaw, 10);
+  if (isNaN(roadmapPosition)) return null;
+  const createdSprint = parseInt(createdSprintRaw, 10);
+  if (isNaN(createdSprint)) return null;
+  const completedAt = parseOptionalYamlField(block, "completedAt");
+  const commitDate = parseOptionalYamlField(block, "commitDate");
+  const completedSprintRaw = parseOptionalYamlField(block, "completedSprint");
+  const completedSprint = completedSprintRaw ? parseInt(completedSprintRaw, 10) : void 0;
+  return {
+    id,
+    displayId,
+    slug,
+    name,
+    description,
+    status,
+    roadmapPosition,
+    createdAt,
+    completedAt,
+    commitDate,
+    createdSprint,
+    completedSprint: completedSprint !== void 0 && !isNaN(completedSprint) ? completedSprint : void 0
+  };
+}
+function serializeFeatures(features) {
+  const sorted = [...features].sort((a, b) => a.roadmapPosition - b.roadmapPosition);
+  const yamlLines = ["features:"];
+  for (const f of sorted) {
+    yamlLines.push(`  - id: "${f.id}"`);
+    yamlLines.push(`    displayId: "${f.displayId}"`);
+    yamlLines.push(`    slug: "${f.slug}"`);
+    yamlLines.push(`    name: "${f.name}"`);
+    yamlLines.push(`    description: "${f.description}"`);
+    yamlLines.push(`    status: "${f.status}"`);
+    yamlLines.push(`    roadmapPosition: ${f.roadmapPosition}`);
+    yamlLines.push(`    createdAt: "${f.createdAt}"`);
+    if (f.completedAt) yamlLines.push(`    completedAt: "${f.completedAt}"`);
+    if (f.commitDate) yamlLines.push(`    commitDate: "${f.commitDate}"`);
+    yamlLines.push(`    createdSprint: ${f.createdSprint}`);
+    if (f.completedSprint !== void 0) yamlLines.push(`    completedSprint: ${f.completedSprint}`);
+  }
+  return yamlLines.join("\n");
+}
+function writeFeaturesToContent(features, content) {
+  const yaml4 = serializeFeatures(features);
+  const newSection = `${FEATURES_START}
+
+\`\`\`yaml
+${yaml4}
+\`\`\`
+
+${FEATURES_END}`;
+  const startIdx = content.indexOf(FEATURES_START);
+  const endIdx = content.indexOf(FEATURES_END);
+  if (startIdx !== -1 && endIdx !== -1) {
+    return content.slice(0, startIdx) + newSection + content.slice(endIdx + FEATURES_END.length);
+  }
+  return content.trimEnd() + "\n\n" + newSection + "\n";
+}
+
+// src/parsers/sprints.ts
+import yaml2 from "js-yaml";
+var YAML_MARKER2 = "<!-- PAPI-ADAPTER: parse the yaml block below -->";
+var YAML_START2 = "<!-- PAPI-YAML-START -->";
+var YAML_END2 = "<!-- PAPI-YAML-END -->";
+var VALID_STATUSES3 = /* @__PURE__ */ new Set(["planning", "active", "complete"]);
+function toSprint(raw) {
+  if (!VALID_STATUSES3.has(raw.status)) return null;
+  const sprint = {
+    id: raw.id,
+    number: raw.number,
+    status: raw.status,
+    startDate: raw.start_date,
+    goals: raw.goals ?? [],
+    boardHealth: raw.board_health ?? "",
+    taskIds: raw.task_ids ?? []
+  };
+  if (raw.end_date) sprint.endDate = raw.end_date;
+  return sprint;
+}
+function fromSprint(sprint) {
+  const raw = {
+    id: sprint.id,
+    number: sprint.number,
+    status: sprint.status,
+    start_date: sprint.startDate,
+    goals: sprint.goals,
+    board_health: sprint.boardHealth,
+    task_ids: sprint.taskIds
+  };
+  if (sprint.endDate) raw.end_date = sprint.endDate;
+  return raw;
+}
+function extractYamlBlock2(content) {
+  const markerIdx = content.indexOf(YAML_MARKER2);
+  if (markerIdx === -1) throw new Error("PAPI-ADAPTER marker not found in SPRINTS.md");
+  const afterMarker = content.slice(markerIdx + YAML_MARKER2.length);
+  const startIdx = afterMarker.indexOf(YAML_START2);
+  if (startIdx === -1) throw new Error("PAPI-YAML-START marker not found in SPRINTS.md");
+  const yamlStart = startIdx + YAML_START2.length;
+  const endIdx = afterMarker.indexOf(YAML_END2, yamlStart);
+  if (endIdx === -1) throw new Error("PAPI-YAML-END marker not found in SPRINTS.md");
+  return afterMarker.slice(yamlStart, endIdx);
+}
+function parseSprints(content) {
+  if (!content.trim()) return [];
+  const yamlText = extractYamlBlock2(content);
+  const data = yaml2.load(yamlText);
+  return (data.sprints ?? []).map(toSprint).filter((s) => s !== null);
+}
+function serializeSprints(sprints, content) {
+  const raw = sprints.map(fromSprint);
+  const yamlStr = yaml2.dump({ sprints: raw }, { lineWidth: 120, quotingType: '"' });
+  const markerIdx = content.indexOf(YAML_MARKER2);
+  if (markerIdx === -1) throw new Error("PAPI-ADAPTER marker not found in SPRINTS.md");
+  const afterMarker = content.slice(markerIdx + YAML_MARKER2.length);
+  const startIdx = afterMarker.indexOf(YAML_START2);
+  if (startIdx === -1) throw new Error("PAPI-YAML-START marker not found in SPRINTS.md");
+  const absStart = markerIdx + YAML_MARKER2.length + startIdx;
+  const endIdx = afterMarker.indexOf(YAML_END2, startIdx);
+  if (endIdx === -1) throw new Error("PAPI-YAML-END marker not found in SPRINTS.md");
+  const absEnd = markerIdx + YAML_MARKER2.length + endIdx + YAML_END2.length;
+  return content.slice(0, absStart) + YAML_START2 + "\n" + yamlStr + YAML_END2 + content.slice(absEnd);
+}
+function serializeSprint(sprint) {
+  const raw = fromSprint(sprint);
+  return yaml2.dump(raw, { lineWidth: 120, quotingType: '"' }).trim();
+}
+function prependSprint(sprint, content) {
+  if (!content.trim()) {
+    const header = `# Sprints
+
+<!-- PAPI-ADAPTER: parse the yaml block below -->
+
+`;
+    const raw = fromSprint(sprint);
+    const yamlStr = yaml2.dump({ sprints: [raw] }, { lineWidth: 120, quotingType: '"' });
+    return header + YAML_START2 + "\n" + yamlStr + YAML_END2 + "\n";
+  }
+  const existing = parseSprints(content);
+  const merged = [sprint, ...existing];
+  return serializeSprints(merged, content);
+}
+
+// src/parsers/registries.ts
+import yaml3 from "js-yaml";
+var YAML_MARKER3 = "<!-- PAPI-ADAPTER: parse the yaml block below -->";
+var YAML_START3 = "<!-- PAPI-YAML-START -->";
+var YAML_END3 = "<!-- PAPI-YAML-END -->";
+function extractYamlBlock3(content) {
+  const markerIdx = content.indexOf(YAML_MARKER3);
+  if (markerIdx === -1) throw new Error("PAPI-ADAPTER marker not found in REGISTRIES.md");
+  const afterMarker = content.slice(markerIdx + YAML_MARKER3.length);
+  const startIdx = afterMarker.indexOf(YAML_START3);
+  if (startIdx === -1) throw new Error("PAPI-YAML-START marker not found in REGISTRIES.md");
+  const yamlStart = startIdx + YAML_START3.length;
+  const endIdx = afterMarker.indexOf(YAML_END3, yamlStart);
+  if (endIdx === -1) throw new Error("PAPI-YAML-END marker not found in REGISTRIES.md");
+  return afterMarker.slice(yamlStart, endIdx);
+}
+function parseRegistries(content) {
+  if (!content.trim()) return { modules: [], epics: [] };
+  const yamlText = extractYamlBlock3(content);
+  const data = yaml3.load(yamlText);
+  return {
+    modules: data.modules ?? [],
+    epics: data.epics ?? []
+  };
+}
+function serializeRegistries(registries, content) {
+  const yamlStr = yaml3.dump(
+    { modules: registries.modules, epics: registries.epics },
+    { lineWidth: 120, quotingType: '"' }
+  );
+  const markerIdx = content.indexOf(YAML_MARKER3);
+  if (markerIdx === -1) throw new Error("PAPI-ADAPTER marker not found in REGISTRIES.md");
+  const afterMarker = content.slice(markerIdx + YAML_MARKER3.length);
+  const startIdx = afterMarker.indexOf(YAML_START3);
+  if (startIdx === -1) throw new Error("PAPI-YAML-START marker not found in REGISTRIES.md");
+  const absStart = markerIdx + YAML_MARKER3.length + startIdx;
+  const endIdx = afterMarker.indexOf(YAML_END3, startIdx);
+  if (endIdx === -1) throw new Error("PAPI-YAML-END marker not found in REGISTRIES.md");
+  const absEnd = markerIdx + YAML_MARKER3.length + endIdx + YAML_END3.length;
+  return content.slice(0, absStart) + YAML_START3 + "\n" + yamlStr + YAML_END3 + content.slice(absEnd);
+}
+
+// src/adapter.ts
+function displayIdNumber(displayId, prefix) {
+  if (!displayId) return 0;
+  const match = displayId.match(new RegExp(`^${prefix}-(\\d+)$`));
+  return match ? parseInt(match[1], 10) : 0;
+}
+var MdFileAdapter = class {
+  dir;
+  constructor(projectDir) {
+    this.dir = projectDir;
+  }
+  /** Resolve a filename to an absolute path within the .papi/ directory. */
+  path(file) {
+    return join(this.dir, file);
+  }
+  /** Read a .papi/ file as UTF-8 text. Throws a clear error if the file is missing. */
+  async read(file) {
+    try {
+      return await readFile(this.path(file), "utf-8");
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+        throw new Error(`.papi/${file} not found. Run the setup tool to initialise your project.`);
+      }
+      throw err;
+    }
+  }
+  /** Write UTF-8 text to a .papi/ file. */
+  async write(file, content) {
+    await writeFile(this.path(file), content, "utf-8");
+  }
+  // --- Planning Log ---
+  /** Parse the full planning context into structured sections (reads from PLANNING_LOG.md + ACTIVE_DECISIONS.md + SPRINT_LOG.md). */
+  async readPlanningLog() {
+    const [planningContent, activeDecisionsContent, sprintLogContent] = await Promise.all([
+      this.read("PLANNING_LOG.md"),
+      this.readOptional("ACTIVE_DECISIONS.md"),
+      this.readOptional("SPRINT_LOG.md")
+    ]);
+    return parsePlanningLog(planningContent, activeDecisionsContent, sprintLogContent);
+  }
+  /** Read the Sprint Health table from PLANNING_LOG.md. */
+  async getSprintHealth() {
+    return parseSprintHealth(await this.read("PLANNING_LOG.md"));
+  }
+  /** Read all Active Decisions from ACTIVE_DECISIONS.md. */
+  async getActiveDecisions() {
+    const content = await this.readOptional("ACTIVE_DECISIONS.md");
+    if (!content) return [];
+    return parseActiveDecisions(content);
+  }
+  /** Read sprint log entries (newest first), optionally limited to {@link limit} entries. */
+  async getSprintLog(limit) {
+    return parseSprintLog(await this.read("SPRINT_LOG.md"), limit);
+  }
+  async getSprintLogSince(sprintNumber) {
+    const log = await this.getSprintLog();
+    return log.filter((entry) => entry.sprintNumber >= sprintNumber);
+  }
+  /** Merge partial updates into the Sprint Health table and write back. */
+  async setSprintHealth(updates) {
+    const content = await this.read("PLANNING_LOG.md");
+    const current = parseSprintHealth(content);
+    const updated = { ...current, ...updates };
+    await this.write("PLANNING_LOG.md", serializeSprintHealth(updated, content));
+  }
+  /** Prepend a new sprint log entry at the top of the Sprint Log section. */
+  async writeSprintLogEntry(entry) {
+    if (!entry.uuid) {
+      entry = { ...entry, uuid: randomUUID6() };
+    }
+    const content = await this.read("SPRINT_LOG.md");
+    await this.write("SPRINT_LOG.md", prependSprintLogEntry(entry, content));
+  }
+  /** Write a strategy review — for md adapter, delegates to sprint log. */
+  async writeStrategyReview(review) {
+    await this.writeSprintLogEntry({
+      uuid: randomUUID6(),
+      sprintNumber: review.sprintNumber,
+      title: review.title,
+      content: review.content,
+      notes: review.notes
+    });
+  }
+  /** Get the sprint number of the last strategy review. */
+  async getLastStrategyReviewSprint() {
+    const log = await this.getSprintLog();
+    const entry = log.find(
+      (e) => /strategy.*review|strategic.*shift/i.test(e.title)
+    );
+    return entry?.sprintNumber ?? 0;
+  }
+  /** Get strategy reviews — md adapter returns empty (reviews live in sprint log). */
+  async getStrategyReviews(_limit) {
+    return [];
+  }
+  /** Update or insert an Active Decision block by ID. */
+  async updateActiveDecision(id, body, sprintNumber) {
+    const content = await this.readOptional("ACTIVE_DECISIONS.md") || "## Active Decisions\n\n";
+    await this.write("ACTIVE_DECISIONS.md", updateActiveDecisionInContent(id, body, content, sprintNumber));
+  }
+  // --- Sprint Board ---
+  /** Query the sprint board, optionally filtering by status/priority/phase/etc. */
+  async queryBoard(options) {
+    const tasks = parseBoard(await this.read("SPRINT_BOARD.md"));
+    return options ? filterTasks(tasks, options) : tasks;
+  }
+  /** Look up a single task by ID, returning null if not found. */
+  async getTask(id) {
+    const tasks = parseBoard(await this.read("SPRINT_BOARD.md"));
+    const found = tasks.find((t) => t.id === id);
+    if (found) return found;
+    const archiveContent = await this.readOptional("ARCHIVE_SPRINT_BOARD.md");
+    if (!archiveContent) return null;
+    return parseBoard(archiveContent).find((t) => t.id === id) ?? null;
+  }
+  /** Look up multiple tasks by ID in a single board read. */
+  async getTasks(ids) {
+    const idSet = new Set(ids);
+    const tasks = parseBoard(await this.read("SPRINT_BOARD.md"));
+    return tasks.filter((t) => idSet.has(t.id));
+  }
+  /** Warn if a phase name doesn't match any known phase label from PRODUCT_BRIEF.md. */
+  async warnInvalidPhase(phase) {
+    const phases = await this.readPhases();
+    if (phases.length === 0) return;
+    const knownLabels = new Set(phases.map((p) => p.label));
+    if (!knownLabels.has(phase)) {
+      console.warn(`[papi] Warning: phase "${phase}" does not match any known phase. Valid phases: ${[...knownLabels].join(", ")}`);
+    }
+  }
+  /** Warn if a module name doesn't match any registered module in REGISTRIES.md. */
+  async warnInvalidModule(module) {
+    const registries = await this.readRegistries();
+    if (registries.modules.length === 0) return;
+    const known = new Set(registries.modules);
+    if (!known.has(module)) {
+      console.warn(`[papi] Warning: module "${module}" is not a registered module. Registered modules: ${registries.modules.join(", ")}`);
+    }
+  }
+  /** Warn if an epic name doesn't match any registered epic in REGISTRIES.md. */
+  async warnInvalidEpic(epic) {
+    const registries = await this.readRegistries();
+    if (registries.epics.length === 0) return;
+    const known = new Set(registries.epics);
+    if (!known.has(epic)) {
+      console.warn(`[papi] Warning: epic "${epic}" is not a registered epic. Registered epics: ${registries.epics.join(", ")}`);
+    }
+  }
+  /** Create a new task on the board with an auto-generated sequential ID. */
+  async createTask(task) {
+    const content = await this.read("SPRINT_BOARD.md");
+    const tasks = parseBoard(content);
+    const createdAt = task.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    const archiveContent = await this.readOptional("ARCHIVE_SPRINT_BOARD.md");
+    const archivedTasks = archiveContent ? parseBoard(archiveContent) : [];
+    await this.warnInvalidPhase(task.phase);
+    await this.warnInvalidModule(task.module);
+    await this.warnInvalidEpic(task.epic);
+    if (task.dependsOn) {
+      const allTaskIds = new Set([...tasks, ...archivedTasks].map((t) => t.id));
+      const depIds = task.dependsOn.split(",").map((s) => s.trim()).filter(Boolean);
+      for (const depId of depIds) {
+        if (!allTaskIds.has(depId)) {
+          console.warn(`[papi] Warning: dependsOn references non-existent task "${depId}"`);
+        }
+      }
+    }
+    const uuid = task.uuid ?? randomUUID6();
+    const id = nextTaskId([...tasks, ...archivedTasks]);
+    const newTask = { ...task, uuid, createdAt, id, displayId: id };
+    if (newTask.buildHandoff) {
+      if (!newTask.buildHandoff.uuid) {
+        newTask.buildHandoff = { ...newTask.buildHandoff, uuid: randomUUID6() };
+      }
+      if (!newTask.buildHandoff.displayId) {
+        const maxNum = tasks.reduce((max, t) => Math.max(max, displayIdNumber(t.buildHandoff?.displayId, "ho")), 0);
+        newTask.buildHandoff = { ...newTask.buildHandoff, displayId: `ho-${maxNum + 1}` };
+      }
+    }
+    tasks.push(newTask);
+    await this.write("SPRINT_BOARD.md", serializeBoard(tasks, content));
+    return newTask;
+  }
+  /** Update one or more fields on an existing task. Throws if the task ID is not found. */
+  async updateTask(id, updates, options) {
+    const content = await this.read("SPRINT_BOARD.md");
+    const tasks = parseBoard(content);
+    const idx = tasks.findIndex((t) => t.id === id);
+    if (idx === -1) throw new Error(`Task ${id} not found`);
+    if (updates.phase && updates.phase !== tasks[idx].phase) {
+      await this.warnInvalidPhase(updates.phase);
+    }
+    if (updates.module && updates.module !== tasks[idx].module) {
+      await this.warnInvalidModule(updates.module);
+    }
+    if (updates.epic && updates.epic !== tasks[idx].epic) {
+      await this.warnInvalidEpic(updates.epic);
+    }
+    if (updates.status && updates.status !== tasks[idx].status && !options?.force) {
+      const from = tasks[idx].status;
+      const allowed = VALID_TRANSITIONS[from];
+      if (!allowed.includes(updates.status)) {
+        console.warn(`[papi] Warning: invalid status transition "${from}" \u2192 "${updates.status}" for task ${id}. Allowed from "${from}": ${allowed.length > 0 ? allowed.join(", ") : "none"}`);
+      }
+    }
+    if (updates.status && updates.status !== tasks[idx].status) {
+      const history = tasks[idx].stateHistory ?? [];
+      history.push({ status: updates.status, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      updates = { ...updates, stateHistory: history };
+    }
+    if (updates.buildHandoff) {
+      let handoff = { ...updates.buildHandoff };
+      if (!handoff.uuid) handoff = { ...handoff, uuid: randomUUID6() };
+      if (!handoff.displayId) {
+        const maxNum = tasks.reduce((max, t) => Math.max(max, displayIdNumber(t.buildHandoff?.displayId, "ho")), 0);
+        handoff = { ...handoff, displayId: `ho-${maxNum + 1}` };
+      }
+      updates = { ...updates, buildHandoff: handoff };
+    }
+    tasks[idx] = { ...tasks[idx], ...updates };
+    await this.write("SPRINT_BOARD.md", serializeBoard(tasks, content));
+  }
+  /** Shorthand to update only the status field of a task. */
+  async updateTaskStatus(id, status) {
+    return this.updateTask(id, { status });
+  }
+  // --- Build Reports ---
+  /** Insert a new build report at the top of BUILD_REPORTS.md. */
+  async appendBuildReport(report) {
+    const boardTasks = parseBoard(await this.read("SPRINT_BOARD.md"));
+    if (!boardTasks.some((t) => t.id === report.taskId)) {
+      const archiveContent = await this.readOptional("ARCHIVE_SPRINT_BOARD.md");
+      const archivedTasks = archiveContent ? parseBoard(archiveContent) : [];
+      if (!archivedTasks.some((t) => t.id === report.taskId)) {
+        console.warn(`[papi] Warning: BuildReport.taskId references non-existent task "${report.taskId}"`);
+      }
+    }
+    const content = await this.read("BUILD_REPORTS.md");
+    if (!report.uuid) {
+      report = { ...report, uuid: randomUUID6() };
+    }
+    if (!report.displayId) {
+      const existing = parseBuildReports(content);
+      const maxNum = existing.reduce((max, r) => Math.max(max, displayIdNumber(r.displayId, "br")), 0);
+      report = { ...report, displayId: `br-${maxNum + 1}` };
+    }
+    await this.write("BUILD_REPORTS.md", prependBuildReport(report, content));
+  }
+  /** Return the most recent {@link count} build reports. */
+  async getRecentBuildReports(count) {
+    const reports = parseBuildReports(await this.read("BUILD_REPORTS.md"));
+    return reports.slice(0, count);
+  }
+  /** Return all build reports from sprints >= {@link sprintNumber}. */
+  async getBuildReportsSince(sprintNumber) {
+    const reports = parseBuildReports(await this.read("BUILD_REPORTS.md"));
+    return reports.filter((r) => r.sprint >= sprintNumber);
+  }
+  // --- Human Reviews ---
+  /** Return recent human reviews from REVIEWS.md (newest first), optionally limited to {@link count}. */
+  async getRecentReviews(count) {
+    const content = await this.readOptional("REVIEWS.md");
+    if (!content) return [];
+    const reviews = parseReviews(content);
+    return count ? reviews.slice(0, count) : reviews;
+  }
+  /** Write a new human review to REVIEWS.md. */
+  async writeReview(review) {
+    const boardTasks = parseBoard(await this.read("SPRINT_BOARD.md"));
+    if (!boardTasks.some((t) => t.id === review.taskId)) {
+      const archiveContent = await this.readOptional("ARCHIVE_SPRINT_BOARD.md");
+      const archivedTasks = archiveContent ? parseBoard(archiveContent) : [];
+      if (!archivedTasks.some((t) => t.id === review.taskId)) {
+        console.warn(`[papi] Warning: HumanReview.taskId references non-existent task "${review.taskId}"`);
+      }
+    }
+    const content = await this.readOptional("REVIEWS.md");
+    if (!review.uuid) {
+      review = { ...review, uuid: randomUUID6() };
+    }
+    if (!review.displayId) {
+      const existing = content ? parseReviews(content) : [];
+      const maxNum = existing.reduce((max, r) => Math.max(max, displayIdNumber(r.displayId, "rv")), 0);
+      review = { ...review, displayId: `rv-${maxNum + 1}` };
+    }
+    await this.write("REVIEWS.md", prependReview(review, content));
+  }
+  // --- Compression ---
+  /** Compress old sprint log entries below {@link threshold} into a summary block. */
+  async compressSprintLog(threshold, summary) {
+    const content = await this.read("SPRINT_LOG.md");
+    await this.write("SPRINT_LOG.md", compressSprintLogInContent(content, threshold, summary));
+  }
+  /** Compress old build reports below {@link threshold} into a summary block. */
+  async compressBuildReports(threshold, summary) {
+    const content = await this.read("BUILD_REPORTS.md");
+    await this.write("BUILD_REPORTS.md", compressBuildReportsInContent(content, threshold, summary));
+  }
+  // --- Archival ---
+  /** Read a .papi/ file, returning empty string if it doesn't exist. */
+  async readOptional(file) {
+    try {
+      await access(this.path(file));
+      return readFile(this.path(file), "utf-8");
+    } catch (_err) {
+      return "";
+    }
+  }
+  /** Strip build_handoff and build_report from a task before archiving — these are already in BUILD_REPORTS.md. */
+  stripHeavyFields(task) {
+    const { buildHandoff, buildReport, ...rest } = task;
+    return rest;
+  }
+  /** Append tasks to ARCHIVE_SPRINT_BOARD.md, stripping heavy fields and deduplicating by ID. */
+  async appendToArchive(tasks) {
+    const existing = await this.readOptional("ARCHIVE_SPRINT_BOARD.md");
+    const archiveContent = existing || "# PAPI Sprint Board \u2014 Archive\n\n<!-- PAPI-ADAPTER: parse the yaml block below -->\n\n<!-- PAPI-YAML-START -->\ntasks: []\n<!-- PAPI-YAML-END -->\n";
+    const existingArchived = parseBoard(archiveContent);
+    const existingIds = new Set(existingArchived.map((t) => t.id));
+    const newArchive = tasks.filter((t) => !existingIds.has(t.id)).map((t) => this.stripHeavyFields(t));
+    const merged = [...existingArchived, ...newArchive];
+    await this.write("ARCHIVE_SPRINT_BOARD.md", serializeBoard(merged, archiveContent));
+  }
+  /** Archive tasks matching phases and/or statuses to ARCHIVE_SPRINT_BOARD.md and remove them from active board. */
+  async archiveTasks(phases, statuses) {
+    const content = await this.read("SPRINT_BOARD.md");
+    const tasks = parseBoard(content);
+    const phaseSet = new Set(phases.map((p) => p.toLowerCase()));
+    const statusSet = statuses ? new Set(statuses.map((s) => s.toLowerCase())) : null;
+    const keep = [];
+    const archive = [];
+    const hasPhaseFilter = phaseSet.size > 0;
+    const hasStatusFilter = statusSet !== null;
+    for (const task of tasks) {
+      const matchesPhase = hasPhaseFilter && phaseSet.has(task.phase.toLowerCase());
+      const matchesStatus = hasStatusFilter && statusSet.has(task.status.toLowerCase());
+      const shouldArchive = hasPhaseFilter && hasStatusFilter ? matchesPhase && matchesStatus : matchesPhase || matchesStatus;
+      if (shouldArchive) {
+        archive.push(task);
+      } else {
+        keep.push(task);
+      }
+    }
+    if (archive.length === 0) {
+      return { archivedCount: 0, taskIds: [] };
+    }
+    await this.appendToArchive(archive);
+    await this.write("SPRINT_BOARD.md", serializeBoard(keep, content));
+    return { archivedCount: archive.length, taskIds: archive.map((t) => t.id) };
+  }
+  // --- Product Brief ---
+  /** Read the raw PRODUCT_BRIEF.md content. */
+  async readProductBrief() {
+    return this.read("PRODUCT_BRIEF.md");
+  }
+  /** Overwrite PRODUCT_BRIEF.md with new content. */
+  async updateProductBrief(content) {
+    await this.write("PRODUCT_BRIEF.md", content);
+  }
+  /** Read all phases from PHASES.md (falls back to PRODUCT_BRIEF.md for migration). */
+  async readPhases() {
+    const phasesContent = await this.readOptional("PHASES.md");
+    if (phasesContent) return parsePhases(phasesContent);
+    const briefContent = await this.readOptional("PRODUCT_BRIEF.md");
+    return briefContent ? parsePhases(briefContent) : [];
+  }
+  /** Write phases to PHASES.md. */
+  async writePhases(phases) {
+    const content = await this.readOptional("PHASES.md");
+    const existing = content || "";
+    const yaml4 = serializePhases(phases);
+    const PHASES_START2 = "<!-- PHASES:START -->";
+    const PHASES_END2 = "<!-- PHASES:END -->";
+    const newSection = `${PHASES_START2}
+
+\`\`\`yaml
+${yaml4}
+\`\`\`
+
+${PHASES_END2}`;
+    const startIdx = existing.indexOf(PHASES_START2);
+    const endIdx = existing.indexOf(PHASES_END2);
+    if (startIdx !== -1 && endIdx !== -1) {
+      await this.write("PHASES.md", existing.slice(0, startIdx) + newSection + existing.slice(endIdx + PHASES_END2.length));
+    } else {
+      await this.write("PHASES.md", `# Phases
+
+${newSection}
+`);
+    }
+  }
+  // --- Features ---
+  /** Read all features from FEATURES.md. */
+  async readFeatures() {
+    const content = await this.readOptional("FEATURES.md");
+    return content ? parseFeatures(content) : [];
+  }
+  /** Get a single feature by UUID. */
+  async getFeature(id) {
+    const features = await this.readFeatures();
+    return features.find((f) => f.id === id) ?? null;
+  }
+  /** Create a new feature and append it to FEATURES.md. */
+  async createFeature(feature) {
+    const features = await this.readFeatures();
+    const id = randomUUID6();
+    const newFeature = { id, ...feature };
+    features.push(newFeature);
+    await this.writeFeatures(features);
+    return newFeature;
+  }
+  /** Update an existing feature by UUID. */
+  async updateFeature(id, updates) {
+    const features = await this.readFeatures();
+    const idx = features.findIndex((f) => f.id === id);
+    if (idx === -1) throw new Error(`Feature not found: ${id}`);
+    features[idx] = { ...features[idx], ...updates };
+    await this.writeFeatures(features);
+  }
+  /** Write all features to FEATURES.md. */
+  async writeFeatures(features) {
+    const content = await this.readOptional("FEATURES.md");
+    const existing = content || "";
+    const yaml4 = serializeFeatures(features);
+    const FEATURES_START2 = "<!-- FEATURES:START -->";
+    const FEATURES_END2 = "<!-- FEATURES:END -->";
+    const newSection = `${FEATURES_START2}
+
+\`\`\`yaml
+${yaml4}
+\`\`\`
+
+${FEATURES_END2}`;
+    const startIdx = existing.indexOf(FEATURES_START2);
+    const endIdx = existing.indexOf(FEATURES_END2);
+    if (startIdx !== -1 && endIdx !== -1) {
+      await this.write("FEATURES.md", existing.slice(0, startIdx) + newSection + existing.slice(endIdx + FEATURES_END2.length));
+    } else {
+      await this.write("FEATURES.md", `# Features
+
+${newSection}
+`);
+    }
+  }
+  // --- Tool Call Metrics ---
+  /** Append a tool call metric entry to METRICS.md. */
+  async appendToolMetric(metric) {
+    const content = await this.readOptional("METRICS.md");
+    await this.write("METRICS.md", appendToolMetricToContent(metric, content));
+  }
+  /** Read all tool call metrics from METRICS.md. */
+  async readToolMetrics() {
+    const content = await this.readOptional("METRICS.md");
+    if (!content) return [];
+    return parseToolMetrics(content);
+  }
+  /** Aggregate tool call metrics into a cost summary, optionally filtered by sprint. */
+  async getCostSummary(sprintNumber) {
+    const metrics = await this.readToolMetrics();
+    return aggregateCostSummary(metrics, sprintNumber);
+  }
+  /** Write a cost snapshot to the Cost Summary section of METRICS.md. */
+  async writeCostSnapshot(snapshot) {
+    const content = await this.readOptional("METRICS.md");
+    await this.write("METRICS.md", writeCostSnapshotToContent(snapshot, content));
+  }
+  /** Read all cost snapshots from the Cost Summary section of METRICS.md. */
+  async getCostSnapshots() {
+    const content = await this.readOptional("METRICS.md");
+    if (!content) return [];
+    return parseCostSnapshots(content);
+  }
+  // --- Sprint Methodology Metrics ---
+  /** Append a sprint metrics snapshot to SPRINT_METRICS.md. */
+  async appendSprintMetrics(snapshot) {
+    const content = await this.readOptional("SPRINT_METRICS.md");
+    await this.write("SPRINT_METRICS.md", appendSnapshotToContent(snapshot, content));
+  }
+  /** Read all sprint metrics snapshots from SPRINT_METRICS.md. */
+  async readSprintMetrics() {
+    const content = await this.readOptional("SPRINT_METRICS.md");
+    if (!content) return [];
+    return parseSnapshots(content);
+  }
+  // --- Sprints ---
+  /** Read all Sprint entities from SPRINTS.md (newest first). */
+  async readSprints() {
+    const content = await this.readOptional("SPRINTS.md");
+    if (!content) return [];
+    return parseSprints(content);
+  }
+  /** Write a new Sprint entity to SPRINTS.md. */
+  async createSprint(sprint) {
+    const content = await this.readOptional("SPRINTS.md");
+    await this.write("SPRINTS.md", prependSprint(sprint, content));
+  }
+  // --- Registries ---
+  /** Read module and epic registries from REGISTRIES.md. */
+  async readRegistries() {
+    const content = await this.readOptional("REGISTRIES.md");
+    if (!content) return { modules: [], epics: [] };
+    return parseRegistries(content);
+  }
+  /** Overwrite REGISTRIES.md with updated registries. */
+  async updateRegistries(registries) {
+    const content = await this.readOptional("REGISTRIES.md") || "# Registries\n\n<!-- PAPI-ADAPTER: parse the yaml block below -->\n\n<!-- PAPI-YAML-START -->\nmodules: []\nepics: []\n<!-- PAPI-YAML-END -->\n";
+    await this.write("REGISTRIES.md", serializeRegistries(registries, content));
+  }
+  // --- Strategy Recommendations ---
+  /**
+   * Write a new strategy recommendation to STRATEGY_RECOMMENDATIONS.md.
+   * File-based implementation stores as YAML entries.
+   */
+  async writeRecommendation(rec) {
+    const id = randomUUID6();
+    const full = { id, ...rec };
+    const content = await this.readOptional("STRATEGY_RECOMMENDATIONS.md");
+    const header = "# Strategy Recommendations\n\n<!-- PAPI-ADAPTER: parse the yaml block below -->\n\n<!-- PAPI-YAML-START -->\nrecommendations:\n";
+    const footer = "<!-- PAPI-YAML-END -->\n";
+    const entry = [
+      `  - id: ${full.id}`,
+      `    type: ${full.type}`,
+      `    status: ${full.status}`,
+      `    content: ${JSON.stringify(full.content)}`,
+      `    created_sprint: ${full.createdSprint}`,
+      full.actionedSprint != null ? `    actioned_sprint: ${full.actionedSprint}` : null
+    ].filter(Boolean).join("\n");
+    if (!content) {
+      await this.write("STRATEGY_RECOMMENDATIONS.md", `${header}${entry}
+${footer}`);
+    } else {
+      const insertPoint = content.indexOf("<!-- PAPI-YAML-END -->");
+      if (insertPoint === -1) {
+        await this.write("STRATEGY_RECOMMENDATIONS.md", `${header}${entry}
+${footer}`);
+      } else {
+        const updated = content.slice(0, insertPoint) + entry + "\n" + content.slice(insertPoint);
+        await this.write("STRATEGY_RECOMMENDATIONS.md", updated);
+      }
+    }
+    return full;
+  }
+  /** Read all pending (unactioned) strategy recommendations. */
+  async getPendingRecommendations() {
+    const content = await this.readOptional("STRATEGY_RECOMMENDATIONS.md");
+    if (!content) return [];
+    const yamlStart = content.indexOf("<!-- PAPI-YAML-START -->");
+    const yamlEnd = content.indexOf("<!-- PAPI-YAML-END -->");
+    if (yamlStart === -1 || yamlEnd === -1) return [];
+    const yamlBlock = content.slice(yamlStart + "<!-- PAPI-YAML-START -->".length, yamlEnd).trim();
+    const entries = yamlBlock.split(/(?=\s+-\s+id:)/);
+    const recs = [];
+    for (const block of entries) {
+      const idMatch = block.match(/id:\s+(.+)/);
+      const typeMatch = block.match(/type:\s+(.+)/);
+      const statusMatch = block.match(/status:\s+(.+)/);
+      const contentMatch = block.match(/content:\s+(.+)/);
+      const createdMatch = block.match(/created_sprint:\s+(\d+)/);
+      const actionedMatch = block.match(/actioned_sprint:\s+(\d+)/);
+      if (!idMatch || !typeMatch || !statusMatch || !contentMatch || !createdMatch) continue;
+      const status = statusMatch[1].trim();
+      if (status !== "pending") continue;
+      let parsedContent = contentMatch[1].trim();
+      if (parsedContent.startsWith('"') && parsedContent.endsWith('"')) {
+        try {
+          parsedContent = JSON.parse(parsedContent);
+        } catch {
+        }
+      }
+      recs.push({
+        id: idMatch[1].trim(),
+        type: typeMatch[1].trim(),
+        status: "pending",
+        content: parsedContent,
+        createdSprint: parseInt(createdMatch[1], 10),
+        actionedSprint: actionedMatch ? parseInt(actionedMatch[1], 10) : void 0
+      });
+    }
+    return recs;
+  }
+  /** Mark a recommendation as actioned. */
+  async actionRecommendation(id, sprintNumber) {
+    const content = await this.readOptional("STRATEGY_RECOMMENDATIONS.md");
+    if (!content) return;
+    const idPattern = new RegExp(`(\\s+-\\s+id:\\s+${id}\\n(?:.*\\n)*?)(\\s+status:\\s+)pending`);
+    let updated = content.replace(idPattern, `$1$2actioned`);
+    const entryPattern = new RegExp(`(\\s+-\\s+id:\\s+${id}\\n(?:.*\\n)*?)(?=\\s+-\\s+id:|<!-- PAPI-YAML-END -->)`);
+    const entryMatch = updated.match(entryPattern);
+    if (entryMatch && !entryMatch[0].includes("actioned_sprint:")) {
+      const sprintPattern = new RegExp(`(\\s+-\\s+id:\\s+${id}\\n(?:.*\\n)*?\\s+created_sprint:\\s+\\d+)\\n`);
+      updated = updated.replace(sprintPattern, `$1
+    actioned_sprint: ${sprintNumber}
+`);
+    }
+    await this.write("STRATEGY_RECOMMENDATIONS.md", updated);
+  }
+  // -------------------------------------------------------------------------
+  // Decision Events & Scores (markdown persistence)
+  // -------------------------------------------------------------------------
+  async appendDecisionEvent(event) {
+    const id = randomUUID6();
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const full = { ...event, id, createdAt };
+    const content = await this.readOptional("DECISION_EVENTS.md");
+    const header = "# Decision Events\n\n";
+    const entry = `## ${full.decisionId} | ${full.eventType} | Sprint ${full.sprint}
+- **id:** ${full.id}
+- **source:** ${full.source}
+` + (full.sourceRef ? `- **sourceRef:** ${full.sourceRef}
+` : "") + (full.detail ? `- **detail:** ${full.detail}
+` : "") + `- **createdAt:** ${full.createdAt}
+
+---
+
+`;
+    if (!content) {
+      await this.write("DECISION_EVENTS.md", header + entry);
+    } else {
+      await this.write("DECISION_EVENTS.md", content + entry);
+    }
+    return full;
+  }
+  async getDecisionEvents(decisionId, limit) {
+    const all = await this.parseDecisionEvents();
+    const filtered = all.filter((e) => e.decisionId === decisionId);
+    return limit ? filtered.slice(0, limit) : filtered;
+  }
+  async getDecisionEventsSince(sprint) {
+    const all = await this.parseDecisionEvents();
+    return all.filter((e) => e.sprint >= sprint);
+  }
+  async parseDecisionEvents() {
+    const content = await this.readOptional("DECISION_EVENTS.md");
+    if (!content) return [];
+    const events = [];
+    const blocks = content.split("---").filter((b) => b.trim());
+    for (const block of blocks) {
+      const headingMatch = block.match(/^##\s+(\S+)\s+\|\s+(\S+)\s+\|\s+Sprint\s+(\d+)/m);
+      if (!headingMatch) continue;
+      const idMatch = block.match(/\*\*id:\*\*\s+(.+)/);
+      const sourceMatch = block.match(/\*\*source:\*\*\s+(.+)/);
+      const sourceRefMatch = block.match(/\*\*sourceRef:\*\*\s+(.+)/);
+      const detailMatch = block.match(/\*\*detail:\*\*\s+(.+)/);
+      const createdAtMatch = block.match(/\*\*createdAt:\*\*\s+(.+)/);
+      if (!idMatch || !sourceMatch || !createdAtMatch) continue;
+      events.push({
+        id: idMatch[1].trim(),
+        decisionId: headingMatch[1],
+        eventType: headingMatch[2],
+        sprint: parseInt(headingMatch[3], 10),
+        source: sourceMatch[1].trim(),
+        sourceRef: sourceRefMatch?.[1]?.trim(),
+        detail: detailMatch?.[1]?.trim(),
+        createdAt: createdAtMatch[1].trim()
+      });
+    }
+    return events;
+  }
+  async writeDecisionScore(score) {
+    const id = randomUUID6();
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const totalScore = score.effort + score.risk + score.reversibility + score.scaleCost + score.lockIn;
+    const full = { ...score, id, totalScore, createdAt };
+    const content = await this.readOptional("DECISION_SCORES.md");
+    const header = "# Decision Scores\n\n";
+    const entry = `## ${full.decisionId} | Sprint ${full.sprint}
+- **id:** ${full.id}
+- **effort:** ${full.effort}
+- **risk:** ${full.risk}
+- **reversibility:** ${full.reversibility}
+- **scaleCost:** ${full.scaleCost}
+- **lockIn:** ${full.lockIn}
+- **totalScore:** ${full.totalScore}
+` + (full.rationale ? `- **rationale:** ${full.rationale}
+` : "") + `- **createdAt:** ${full.createdAt}
+
+---
+
+`;
+    if (!content) {
+      await this.write("DECISION_SCORES.md", header + entry);
+    } else {
+      await this.write("DECISION_SCORES.md", content + entry);
+    }
+    return full;
+  }
+  async getDecisionScores(decisionId) {
+    const all = await this.parseDecisionScores();
+    return all.filter((s) => s.decisionId === decisionId);
+  }
+  async getLatestDecisionScores() {
+    const all = await this.parseDecisionScores();
+    const latest = /* @__PURE__ */ new Map();
+    for (const s of all) {
+      const existing = latest.get(s.decisionId);
+      if (!existing || s.sprint > existing.sprint) {
+        latest.set(s.decisionId, s);
+      }
+    }
+    return Array.from(latest.values());
+  }
+  async parseDecisionScores() {
+    const content = await this.readOptional("DECISION_SCORES.md");
+    if (!content) return [];
+    const scores = [];
+    const blocks = content.split("---").filter((b) => b.trim());
+    for (const block of blocks) {
+      const headingMatch = block.match(/^##\s+(\S+)\s+\|\s+Sprint\s+(\d+)/m);
+      if (!headingMatch) continue;
+      const field = (name) => block.match(new RegExp(`\\*\\*${name}:\\*\\*\\s+(.+)`))?.[1]?.trim();
+      const id = field("id");
+      const createdAt = field("createdAt");
+      if (!id || !createdAt) continue;
+      scores.push({
+        id,
+        decisionId: headingMatch[1],
+        sprint: parseInt(headingMatch[2], 10),
+        effort: parseInt(field("effort") ?? "0", 10),
+        risk: parseInt(field("risk") ?? "0", 10),
+        reversibility: parseInt(field("reversibility") ?? "0", 10),
+        scaleCost: parseInt(field("scaleCost") ?? "0", 10),
+        lockIn: parseInt(field("lockIn") ?? "0", 10),
+        totalScore: parseInt(field("totalScore") ?? "0", 10),
+        rationale: field("rationale"),
+        createdAt
+      });
+    }
+    return scores;
+  }
+  // Entity reference tracking — no-op for md adapter (DB-only feature)
+  async logEntityReferences(_refs) {
+  }
+  async getDecisionUsage(_currentSprint) {
+    return [];
+  }
+};
+
+// src/parsers/review-patterns.ts
+var NONE_PATTERN2 = /^none\b/i;
+function normalizeText2(text) {
+  return text.trim().toLowerCase().replace(/[.,;:!]+$/, "").replace(/\s+/g, " ");
+}
+function isRealComment(text) {
+  const trimmed = text.trim();
+  return trimmed.length > 0 && !NONE_PATTERN2.test(trimmed);
+}
+async function detectReviewPatterns(reviews, currentSprint, window = 5, clusterer) {
+  const recentReviews = reviews.filter(
+    (r) => r.sprint > currentSprint - window && r.sprint <= currentSprint
+  );
+  let recurringFeedback;
+  const realComments = recentReviews.filter((r) => isRealComment(r.comments));
+  if (clusterer && realComments.length >= 2) {
+    const entries = realComments.map((r) => ({
+      text: r.comments.trim(),
+      source: r.taskId
+    }));
+    const clusters = await clusterer(entries);
+    recurringFeedback = clusters.filter((c) => c.entries.length >= 2).map((c) => ({
+      text: c.theme,
+      count: c.entries.length,
+      taskIds: [...new Set(c.entries.map((e) => e.source))].sort()
+    }));
+    recurringFeedback.sort((a, b) => b.count - a.count);
+  } else {
+    const feedbackMap = /* @__PURE__ */ new Map();
+    for (const r of realComments) {
+      const key = normalizeText2(r.comments);
+      const existing = feedbackMap.get(key);
+      if (existing) {
+        existing.count += 1;
+        existing.taskIds.add(r.taskId);
+      } else {
+        feedbackMap.set(key, { original: r.comments.trim(), count: 1, taskIds: /* @__PURE__ */ new Set([r.taskId]) });
+      }
+    }
+    recurringFeedback = [];
+    for (const entry of feedbackMap.values()) {
+      if (entry.count >= 2) {
+        recurringFeedback.push({
+          text: entry.original,
+          count: entry.count,
+          taskIds: [...entry.taskIds].sort()
+        });
+      }
+    }
+    recurringFeedback.sort((a, b) => b.count - a.count);
+  }
+  const verdictBreakdown = {};
+  for (const r of recentReviews) {
+    verdictBreakdown[r.verdict] = (verdictBreakdown[r.verdict] ?? 0) + 1;
+  }
+  const totalReviews = recentReviews.length;
+  const requestChangesCount = recentReviews.filter((r) => r.verdict === "request-changes").length;
+  const requestChangesRate = totalReviews > 0 ? Math.round(requestChangesCount / totalReviews * 100) : 0;
+  return {
+    recurringFeedback,
+    verdictBreakdown,
+    requestChangesRate
+  };
+}
+function hasReviewPatterns(patterns) {
+  return patterns.recurringFeedback.length > 0 || patterns.requestChangesRate >= 50;
+}
+export {
+  MdFileAdapter,
+  TASK_TYPE_TIERS,
+  VALID_TRANSITIONS,
+  aggregateCostSummary,
+  appendToolMetricToContent,
+  calculateSprintMetrics,
+  detectBuildPatterns,
+  detectReviewPatterns,
+  hasBuildPatterns,
+  hasReviewPatterns,
+  isValidStatus,
+  isValidTransition,
+  parseBuildHandoff,
+  parseEffortSize,
+  parseFeatures,
+  parsePhases,
+  parseRegistries,
+  parseReviews,
+  parseSprints,
+  parseToolMetrics,
+  prependReview,
+  prependSprint,
+  serializeBuildHandoff,
+  serializeFeatures,
+  serializePhases,
+  serializeRegistries,
+  serializeReview,
+  serializeSprint,
+  serializeSprints,
+  serializeToolMetric,
+  validateTransition,
+  writeFeaturesToContent,
+  writePhasesToContent
+};