@papi-ai/adapter-md 0.1.0-alpha → 0.2.0

package/dist/index.js

@@ -8,18 +8,27 @@ import {
   VALID_TRANSITIONS as _VALID_TRANSITIONS,
   isValidTransition as _isValidTransition,
   validateTransition as _validateTransition,
-  isValidStatus as _isValidStatus
+  isValidStatus as _isValidStatus,
+  isLiveDecision as _isLiveDecision,
+  RETIRED_DECISION_OUTCOMES as _RETIRED_DECISION_OUTCOMES
 } from "@papi-ai/shared";
 var VALID_TRANSITIONS = _VALID_TRANSITIONS;
 var isValidTransition = _isValidTransition;
 var validateTransition = _validateTransition;
 var isValidStatus = _isValidStatus;
+var isLiveDecision = _isLiveDecision;
 var TASK_TYPE_TIERS = {
   bug: 1,
   task: 1,
   research: 2,
+  spike: 2,
   idea: 3,
-  feedback: 3
+  discovery: 1,
+  // Non-code brief types for non-technical Owners (AD-12)
+  "design-brief": 1,
+  "research-brief": 1,
+  "marketing-brief": 1,
+  "ops-brief": 1
 };
 
 // src/parsers/planning-log.ts
@@ -36,8 +45,8 @@ 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");
+function parseCycleHealth(content) {
+  const section = extractSectionCompat(content, "Cycle Health", "Sprint Health") || extractSection(content, "Session Health");
   const rows = /* @__PURE__ */ new Map();
   for (const line of section.split("\n")) {
     const match = line.match(/^\|\s*(.+?)\s*\|\s*(.+?)\s*\|$/);
@@ -48,27 +57,29 @@ function parseSprintHealth(content) {
   }
   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,
+    totalCycles: parseInt(get("total cycles") || get("total sprints") || get("total sessions"), 10) || 0,
+    cyclesSinceLastStrategyReview: parseInt(get("cycles since last strategy review") || 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");
+function serializeCycleHealth(health, content) {
+  const section = extractSectionCompat(content, "Cycle Health", "Sprint Health") || extractSection(content, "Session Health");
   const fieldMap = {
-    "Total sprints": String(health.totalSprints),
-    "Sprints since last Strategy Review": String(health.sprintsSinceLastStrategyReview),
+    "Total cycles": String(health.totalCycles),
+    "Cycles since last Strategy Review": String(health.cyclesSinceLastStrategyReview),
     "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)
+    "Total sprints": String(health.totalCycles),
+    "Sprints since last Strategy Review": String(health.cyclesSinceLastStrategyReview),
+    "Total sessions": String(health.totalCycles),
+    "Sessions since last Strategy Review": String(health.cyclesSinceLastStrategyReview)
   };
   let updatedSection = section;
   for (const [metric, value] of Object.entries({ ...fieldMap, ...legacyFieldMap })) {
@@ -86,8 +97,8 @@ function parseActiveDecisions(content) {
     );
     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 createdCycle = metaMatch?.[1] ? parseInt(metaMatch[1], 10) : void 0;
+    const modifiedCycle = metaMatch?.[2] ? parseInt(metaMatch[2], 10) : void 0;
     const uuid = metaMatch?.[3] ?? randomUUID();
     return {
       uuid,
@@ -97,8 +108,8 @@ function parseActiveDecisions(content) {
       confidence: headingMatch[3] ?? "HIGH",
       superseded: !!headingMatch[4],
       supersededBy: headingMatch[4],
-      createdSprint,
-      modifiedSprint,
+      createdCycle,
+      modifiedCycle,
       body: block
     };
   }).filter((d) => d !== null);
@@ -106,16 +117,16 @@ function parseActiveDecisions(content) {
 function stripTemporalMeta(body) {
   return body.replace(/\n?<!-- papi:(?:created_sprint=\d+)?\s*(?:modified_sprint=\d+\s*)*(?:uuid=\S+)? -->/g, "");
 }
-function buildTemporalMeta(createdSprint, modifiedSprint, uuid) {
+function buildTemporalMeta(createdCycle, modifiedCycle, uuid) {
   const parts = [];
-  if (createdSprint != null) parts.push(`created_sprint=${createdSprint}`);
-  if (modifiedSprint != null) parts.push(`modified_sprint=${modifiedSprint}`);
+  if (createdCycle != null) parts.push(`created_sprint=${createdCycle}`);
+  if (modifiedCycle != null) parts.push(`modified_sprint=${modifiedCycle}`);
   if (uuid) parts.push(`uuid=${uuid}`);
   if (parts.length === 0) return "";
   return `
 <!-- papi:${parts.join(" ")} -->`;
 }
-function extractCreatedSprint(block) {
+function extractCreatedCycle(block) {
   const m = block.match(/<!-- papi:(?:created_sprint=(\d+))/);
   return m?.[1] ? parseInt(m[1], 10) : void 0;
 }
@@ -123,19 +134,19 @@ function extractUuid(block) {
   const m = block.match(/<!-- papi:.*?uuid=(\S+)/);
   return m?.[1];
 }
-function updateActiveDecisionInContent(id, newBody, content, sprintNumber) {
+function updateActiveDecisionInContent(id, newBody, content, cycleNumber) {
   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 existingCreated = existingMatch ? extractCreatedCycle(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) : "";
+    const meta2 = cycleNumber != null ? buildTemporalMeta(existingCreated, cycleNumber, existingUuid) : existingUuid ? buildTemporalMeta(existingCreated, void 0, existingUuid) : "";
     return content.replace(pattern, cleanBody.trimEnd() + meta2 + "\n\n");
   }
-  const meta = sprintNumber != null ? buildTemporalMeta(sprintNumber) : "";
+  const meta = cycleNumber != null ? buildTemporalMeta(cycleNumber) : "";
   const sectionPattern = /^(#{1,2} Active Decisions\n)([\s\S]*?)(?=^#{1,2} |$(?![\s\S]))/m;
   const sectionMatch = content.match(sectionPattern);
   if (sectionMatch) {
@@ -146,22 +157,22 @@ function updateActiveDecisionInContent(id, newBody, content, sprintNumber) {
   }
   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+ —/));
+function parseCycleLog(content, limit) {
+  const section = extractSectionCompat(content, "Cycle Log", "Sprint Log");
+  const chunks = section.split(/^(?=### (?:Cycle|Sprint|Session) \d+ —)/m).map((c) => c.trim()).filter((c) => c.match(/^### (?:Cycle|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 headingMatch = block.match(/^### (?:Cycle|Sprint|Session) (\d+) — (.+?)$/m);
+    const cycleNumber = 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 notesMatch = blockClean.match(/\*\*Cycle Notes:\*\*\s*([\s\S]*?)$/);
     const notes = notesMatch ? notesMatch[1].trim() : void 0;
     return {
       uuid: uuid ?? randomUUID(),
-      sprintNumber,
+      cycleNumber,
       title,
       content: block,
       carryForward: carryForwardMatch ? carryForwardMatch[1].trim() : void 0,
@@ -170,11 +181,11 @@ function parseSprintLog(content, limit) {
   });
   return limit ? entries.slice(0, limit) : entries;
 }
-function prependSprintLogEntry(entry, content) {
-  const headingPattern = /^## (?:Sprint|Session) Log\s*$/m;
+function prependCycleLogEntry(entry, content) {
+  const headingPattern = /^## (?:Cycle|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");
+    throw new Error("Cycle Log section not found in Planning Log");
   }
   const insertPos = headingMatch.index + headingMatch[0].length;
   const before = content.slice(0, insertPos);
@@ -183,7 +194,7 @@ function prependSprintLogEntry(entry, content) {
   if (entry.notes) {
     entryContent = `${entryContent}
 
-**Sprint Notes:** ${entry.notes}`;
+**Cycle Notes:** ${entry.notes}`;
   }
   if (entry.uuid) {
     entryContent = `${entryContent}
@@ -197,17 +208,41 @@ ${after}`;
 function parseNorthStar(content) {
   return extractSection(content, "North Star").replace(/^## North Star\s*/m, "").trim();
 }
+function upsertNorthStarInContent(content, statement) {
+  const headingPattern = /^## North Star\s*$/m;
+  const start = content.search(headingPattern);
+  if (start === -1) {
+    const cycleLogIdx = content.search(/^## (?:Cycle Log|Sprint Log)/m);
+    const newSection = `## North Star
+
+${statement}
+
+`;
+    if (cycleLogIdx === -1) {
+      return content.trimEnd() + "\n\n" + newSection;
+    }
+    return content.slice(0, cycleLogIdx) + newSection + content.slice(cycleLogIdx);
+  }
+  const afterHeading = content.slice(start);
+  const nextSection = afterHeading.slice(1).search(/^## /m);
+  const sectionEnd = nextSection === -1 ? content.length : start + nextSection + 1;
+  return content.slice(0, start) + `## North Star
+
+${statement}
+
+` + content.slice(sectionEnd);
+}
 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+ —/));
+function compressCycleLogInContent(content, threshold, summary) {
+  const section = extractSectionCompat(content, "Cycle Log", "Sprint Log");
+  const chunks = section.split(/^(?=### (?:Cycle|Sprint|Session) \d+ —)/m).map((c) => c.trim()).filter((c) => c.match(/^### (?:Cycle|Sprint|Session) \d+ —/));
   const keep = [];
   let hasOld = false;
   for (const block of chunks) {
-    const match = block.match(/^### (?:Sprint|Session) (\d+) —/);
+    const match = block.match(/^### (?:Cycle|Sprint|Session) (\d+) —/);
     const num = match ? parseInt(match[1], 10) : 0;
     if (num >= threshold) {
       keep.push(block);
@@ -216,27 +251,27 @@ function compressSprintLogInContent(content, threshold, summary) {
     }
   }
   if (!hasOld) return content;
-  const summaryBlock = `### Sprints 1\u2013${threshold - 1} \u2014 Compressed Summary
+  const summaryBlock = `### Cycles 1\u2013${threshold - 1} \u2014 Compressed Summary
 
 ${summary}`;
   const newEntries = [...keep, summaryBlock].join("\n\n");
-  const newSection = `## Sprint Log
+  const newSection = `## Cycle Log
 
 ${newEntries}
 `;
   return content.replace(section, newSection);
 }
-function parsePlanningLog(content, activeDecisionsContent, sprintLogContent) {
+function parsePlanningLog(content, activeDecisionsContent, cycleLogContent) {
   return {
-    sprintHealth: parseSprintHealth(content),
+    cycleHealth: parseCycleHealth(content),
     northStar: parseNorthStar(content),
     activeDecisions: parseActiveDecisions(activeDecisionsContent ?? content),
     deferred: parseDeferred(content),
-    sprintLog: sprintLogContent ? parseSprintLog(sprintLogContent) : []
+    cycleLog: cycleLogContent ? parseCycleLog(cycleLogContent) : []
   };
 }
 
-// src/parsers/sprint-board.ts
+// src/parsers/cycle-board.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import yaml from "js-yaml";
 
@@ -248,6 +283,7 @@ var SECTION_HEADERS = [
   "SCOPE BOUNDARY (DO NOT DO THIS)",
   "ACCEPTANCE CRITERIA",
   "SECURITY CONSIDERATIONS",
+  "PRE-BUILD VERIFICATION",
   "FILES LIKELY TOUCHED",
   "EFFORT"
 ];
@@ -278,6 +314,9 @@ function splitSections(text) {
 function parseBulletList(text) {
   return text.split("\n").map((l) => l.replace(/^\s*-\s*/, "").trim()).filter((l) => l.length > 0);
 }
+function parseBulletsOnly(text) {
+  return text.split("\n").filter((l) => /^\s*-\s/.test(l)).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);
 }
@@ -285,11 +324,11 @@ 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 cycleMatch = markdown.match(/^Cycle:\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 cycle = cycleMatch ? parseInt(cycleMatch[1], 10) : 0;
   const whyNow = whyNowMatch?.[1]?.replace(/\s+/g, " ").trim() ?? "";
   const uuidMatch = markdown.match(/^UUID:\s*(\S+)$/m);
   const uuid = uuidMatch?.[1];
@@ -306,59 +345,92 @@ function parseBuildHandoff(markdown) {
     ...createdAt ? { createdAt } : {},
     taskId,
     taskTitle,
-    sprint,
+    cycle,
     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(),
+    verificationFiles: parseBulletsOnly(sections.get("PRE-BUILD VERIFICATION") ?? ""),
     filesLikelyTouched: parseBulletList(sections.get("FILES LIKELY TOUCHED") ?? ""),
     effort
   };
 }
-function serializeBuildHandoff(handoff) {
+function ensureArray(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+    return value.trim() ? [value] : [];
+  }
+  return [];
+}
+function serializeBuildHandoff(raw) {
+  let handoff;
+  if (typeof raw === "string") {
+    try {
+      handoff = JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  } else {
+    handoff = raw;
+  }
   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(`Cycle: ${handoff.cycle}`);
   lines.push(`Why now: ${handoff.whyNow}`);
   lines.push("");
   lines.push("SCOPE (DO THIS)");
-  for (const item of handoff.scope) {
+  for (const item of ensureArray(handoff.scope)) {
     lines.push(`- ${item}`);
   }
   lines.push("");
   lines.push("SCOPE BOUNDARY (DO NOT DO THIS)");
-  for (const item of handoff.scopeBoundary) {
+  for (const item of ensureArray(handoff.scopeBoundary)) {
     lines.push(`- ${item}`);
   }
   lines.push("");
   lines.push("ACCEPTANCE CRITERIA");
-  for (const item of handoff.acceptanceCriteria) {
+  for (const item of ensureArray(handoff.acceptanceCriteria)) {
     lines.push(`[ ] ${item}`);
   }
   lines.push("");
   lines.push("SECURITY CONSIDERATIONS");
-  lines.push(handoff.securityConsiderations);
+  lines.push(handoff.securityConsiderations ?? "");
+  const verificationFiles = ensureArray(handoff.verificationFiles);
+  if (verificationFiles.length > 0) {
+    lines.push("");
+    lines.push("PRE-BUILD VERIFICATION");
+    lines.push("Before implementing, read these files and check if the functionality already exists:");
+    for (const item of verificationFiles) {
+      lines.push(`- ${item}`);
+    }
+    lines.push('If >80% of the scope is already implemented, call build_execute with completed="yes" and note "already built" in surprises instead of re-implementing.');
+  }
   lines.push("");
   lines.push("FILES LIKELY TOUCHED");
-  for (const item of handoff.filesLikelyTouched) {
+  for (const item of ensureArray(handoff.filesLikelyTouched)) {
     lines.push(`- ${item}`);
   }
   lines.push("");
   lines.push("EFFORT");
-  lines.push(handoff.effort);
+  lines.push(handoff.effort ?? "M");
   return lines.join("\n");
 }
 
-// src/parsers/sprint-board.ts
+// src/parsers/cycle-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) {
+function toCycleTask(raw) {
   return {
     uuid: raw.uuid || randomUUID3(),
     id: raw.id,
@@ -372,8 +444,8 @@ function toSprintTask(raw) {
     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,
+    cycle: raw.cycle != null ? raw.cycle : void 0,
+    createdCycle: 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,
@@ -381,13 +453,17 @@ function toSprintTask(raw) {
     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
+    buildReport: raw.build_report || void 0,
+    scopeClass: raw.scope_class === "brief" ? "brief" : "task",
+    assigneeId: raw.assignee_id || void 0,
+    claimSource: raw.claim_source === "pool" || raw.claim_source === "self_generated" ? raw.claim_source : void 0,
+    reviewerId: raw.reviewer_id || void 0
   };
 }
 function sanitizeDelimiters(value) {
   return value.replaceAll(YAML_END, "<!-- PAPI-YAML-END (sanitized) -->");
 }
-function fromSprintTask(task) {
+function fromCycleTask(task) {
   const raw = {
     uuid: task.uuid,
     id: task.id,
@@ -403,8 +479,8 @@ function fromSprintTask(task) {
     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.cycle != null) raw.cycle = task.cycle;
+  if (task.createdCycle != null) raw.created_sprint = task.createdCycle;
   if (task.createdAt) raw.created_at = task.createdAt;
   if (task.why) raw.why = task.why;
   if (task.stateHistory?.length) {
@@ -413,6 +489,10 @@ function fromSprintTask(task) {
   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);
+  if (task.scopeClass && task.scopeClass !== "task") raw.scope_class = task.scopeClass;
+  if (task.assigneeId) raw.assignee_id = task.assigneeId;
+  if (task.claimSource) raw.claim_source = task.claimSource;
+  if (task.reviewerId) raw.reviewer_id = task.reviewerId;
   return raw;
 }
 function mergeConflictHint(content) {
@@ -423,17 +503,17 @@ function mergeConflictHint(content) {
 }
 function extractYamlBlock(content) {
   const markerIdx = content.indexOf(YAML_MARKER);
-  if (markerIdx === -1) throw new Error("PAPI-ADAPTER marker not found in SPRINT_BOARD.md");
+  if (markerIdx === -1) throw new Error("PAPI-ADAPTER marker not found in CYCLE_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");
+    if (endIdx === -1) throw new Error("PAPI-YAML-END marker not found in CYCLE_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");
+  if (!blockMatch) throw new Error("YAML block not found in CYCLE_BOARD.md");
   return blockMatch[1];
 }
 function parseBoard(content) {
@@ -446,27 +526,27 @@ function parseBoard(content) {
     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}`
+      `YAML parse error in CYCLE_BOARD.md${lineInfo}. Check for syntax errors \u2014 unquoted special characters, bad indentation, or missing colons.${hint}`
     );
   }
-  return (data.tasks ?? []).map(toSprintTask);
+  return (data.tasks ?? []).map(toCycleTask);
 }
 function serializeBoard(tasks, content) {
-  const raw = tasks.map(fromSprintTask);
+  const raw = tasks.map(fromCycleTask);
   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");
+  if (markerIdx === -1) throw new Error("PAPI-ADAPTER marker not found in CYCLE_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");
+    if (endIdx === -1) throw new Error("PAPI-YAML-END marker not found in CYCLE_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");
+  if (!blockMatch) throw new Error("YAML block not found in CYCLE_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);
@@ -479,6 +559,7 @@ function filterTasks(tasks, options) {
     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;
+    if (options.assigneeId && task.assigneeId !== options.assigneeId) return false;
     return true;
   });
 }
@@ -508,9 +589,9 @@ function parseEffort(effortLine) {
   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+/));
+  const chunks = content.split(/^(?=### .+ — .+ — (?:Cycle|Sprint|Session) \d+)/m).map((c) => c.trim()).filter((c) => c.match(/^### .+ — .+ — (?:Cycle|Sprint|Session) \d+/));
   return chunks.map((block) => {
-    const headingMatch = block.match(/^### (.+?) — (.+?) — (?:Sprint|Session) (\d+)/);
+    const headingMatch = block.match(/^### (.+?) — (.+?) — (?:Cycle|Sprint|Session) (\d+)/);
     if (!headingMatch) return null;
     const effortLine = parseField(block, "Actual Effort");
     const { actual, estimated } = parseEffort(effortLine);
@@ -533,7 +614,7 @@ function parseBuildReports(content) {
       taskId,
       taskName: headingMatch[1].trim(),
       date: headingMatch[2].trim(),
-      sprint: parseInt(headingMatch[3], 10),
+      cycle: parseInt(headingMatch[3], 10),
       completed: completedRaw.startsWith("Yes") ? "Yes" : completedRaw.startsWith("No") ? "No" : "Partial",
       actualEffort,
       estimatedEffort,
@@ -549,7 +630,7 @@ function parseBuildReports(content) {
 }
 function serializeBuildReport(report) {
   const lines = [
-    `### ${report.taskName} \u2014 ${report.date} \u2014 Sprint ${report.sprint}`
+    `### ${report.taskName} \u2014 ${report.date} \u2014 Cycle ${report.cycle}`
   ];
   if (report.uuid) lines.push(`- **UUID:** ${report.uuid}`);
   if (report.displayId) lines.push(`- **Display ID:** ${report.displayId}`);
@@ -569,14 +650,14 @@ function serializeBuildReport(report) {
   }
   return lines.join("\n");
 }
-function formatCompressedSummary(reports, sprintRange, aiSummary) {
+function formatCompressedSummary(reports, cycleRange, 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`];
+  const lines = [`### ${cycleRange} \u2014 Compressed Summary`];
   lines.push(`**Date range:** ${dateRange}`);
   lines.push(`**Reports:** ${reports.length}`);
   if (completed.length > 0) {
@@ -602,11 +683,11 @@ function formatCompressedSummary(reports, sprintRange, 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 chunks = content.split(/^(?=### .+ — .+ — (?:Cycle|Sprint|Session) \d+)/m).map((c) => c.trim()).filter((c) => c.match(/^### .+ — .+ — (?:Cycle|Sprint|Session) \d+/));
   const keep = [];
   const oldChunks = [];
   for (const block of chunks) {
-    const match = block.match(/— (?:Sprint|Session) (\d+)/);
+    const match = block.match(/— (?:Cycle|Sprint|Session) (\d+)/);
     const num = match ? parseInt(match[1], 10) : 0;
     if (num >= threshold) {
       keep.push(block);
@@ -616,8 +697,8 @@ function compressBuildReportsInContent(content, threshold, summary) {
   }
   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 cycleRange = `Cycles 1\u2013${threshold - 1}`;
+  const summaryBlock = formatCompressedSummary(oldReports, cycleRange, summary);
   const firstReportIdx = content.search(/^### /m);
   const header = firstReportIdx === -1 ? content : content.slice(0, firstReportIdx);
   const entries = [...keep, summaryBlock].join("\n\n---\n\n");
@@ -638,7 +719,7 @@ function mergeBuildReports(existing, incoming) {
     taskId: incoming.taskId,
     taskName: incoming.taskName,
     date: incoming.date,
-    sprint: incoming.sprint,
+    cycle: incoming.cycle,
     completed: incoming.completed,
     actualEffort: incoming.actualEffort,
     estimatedEffort: incoming.estimatedEffort,
@@ -659,8 +740,12 @@ function replaceBuildReport(existing, replacement, content) {
   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);
+  const headingPattern = `### ${existing.taskName} \u2014 ${existing.date} \u2014 Cycle ${existing.cycle}`;
+  let headingIdx = content.indexOf(headingPattern);
+  if (headingIdx === -1) {
+    const legacyPattern = `### ${existing.taskName} \u2014 ${existing.date} \u2014 Sprint ${existing.cycle}`;
+    headingIdx = content.indexOf(legacyPattern);
+  }
   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");
@@ -687,9 +772,9 @@ function prependBuildReport(report, content) {
 }
 
 // src/parsers/metrics.ts
-var TABLE_HEADER = "| Timestamp | Tool | Duration (ms) | Input Tokens | Output Tokens | Cost ($) | Model | Sprint | Context |";
+var TABLE_HEADER = "| Timestamp | Tool | Duration (ms) | Input Tokens | Output Tokens | Cost ($) | Model | Cycle | Context |";
 var TABLE_SEPARATOR = "|-----------|------|---------------|--------------|---------------|----------|-------|--------|---------|";
-var PREV_TABLE_HEADER = "| Timestamp | Tool | Duration (ms) | Input Tokens | Output Tokens | Cost ($) | Model | Sprint |";
+var PREV_TABLE_HEADER = "| Timestamp | Tool | Duration (ms) | Input Tokens | Output Tokens | Cost ($) | Model | Cycle |";
 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
@@ -728,8 +813,8 @@ function parseToolMetrics(content) {
     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 cycleRaw = cells.length >= 8 && cells[7] !== "-" ? parseInt(cells[7], 10) : void 0;
+    const cycleNumber = cycleRaw !== void 0 && !isNaN(cycleRaw) ? cycleRaw : 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;
@@ -742,7 +827,7 @@ function parseToolMetrics(content) {
       ...outputTokens !== void 0 && !isNaN(outputTokens) ? { outputTokens } : {},
       ...cost !== void 0 && !isNaN(cost) ? { estimatedCostUsd: cost } : {},
       ...model ? { model } : {},
-      ...sprintNumber !== void 0 ? { sprintNumber } : {},
+      ...cycleNumber !== void 0 ? { cycleNumber } : {},
       ...contextBytes !== void 0 ? { contextBytes } : {},
       ...contextUtilisation !== void 0 ? { contextUtilisation } : {}
     });
@@ -757,10 +842,10 @@ function serializeToolMetric(metric) {
   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 cycle = metric.cycleNumber !== void 0 ? String(metric.cycleNumber) : "-";
   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} |`;
+  return `| ${metric.timestamp} | ${metric.tool} | ${formatNumber(metric.durationMs)} | ${inputTokens} | ${outputTokens} | ${cost} | ${model} | ${cycle} | ${context} | ${utilisation} |`;
 }
 function appendToolMetricToContent(metric, content) {
   if (!content.trim()) {
@@ -791,8 +876,8 @@ function appendToolMetricToContent(metric, content) {
   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;
+function aggregateCostSummary(metrics, cycleNumber) {
+  const filtered = cycleNumber !== void 0 ? metrics.filter((m) => m.cycleNumber === cycleNumber) : metrics;
   let totalCostUsd = 0;
   let totalInputTokens = 0;
   let totalOutputTokens = 0;
@@ -824,7 +909,6 @@ function aggregateCostSummary(metrics, sprintNumber) {
   };
 }
 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");
@@ -843,7 +927,7 @@ function parseCostSnapshots(content) {
     const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
     if (cells.length < 6) continue;
     snapshots.push({
-      sprint: parseInt(cells[0], 10),
+      cycle: parseInt(cells[0], 10),
       date: cells[1],
       totalCostUsd: parseFloat(cells[2]),
       totalInputTokens: parseInt(cells[3].replace(/,/g, ""), 10),
@@ -853,34 +937,12 @@ function parseCostSnapshots(content) {
   }
   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 |";
+// src/parsers/cycle-metrics.ts
+var FILE_HEADING = "# Cycle Methodology Metrics";
+var ACCURACY_HEADER = "| Cycle | Reports | Match Rate | MAE | Bias |";
 var ACCURACY_SEPARATOR = "|--------|---------|------------|-----|------|";
-var VELOCITY_HEADER = "| Sprint | Completed | Partial | Failed | Effort Points |";
+var VELOCITY_HEADER = "| Cycle | Completed | Partial | Failed | Effort Points |";
 var VELOCITY_SEPARATOR = "|--------|-----------|---------|--------|---------------|";
 var EFFORT_SCALE = {
   XS: 1,
@@ -893,21 +955,21 @@ function effortOrdinal(effort) {
   const normalized = effort.trim().toUpperCase();
   return EFFORT_SCALE[normalized];
 }
-function calculateSprintMetrics(reports, currentSprint, window = 5) {
+function calculateCycleMetrics(reports, currentCycle, window = 5) {
   const recentReports = reports.filter(
-    (r) => r.sprint > currentSprint - window && r.sprint <= currentSprint
+    (r) => r.cycle > currentCycle - window && r.cycle <= currentCycle
   );
-  const perSprint = /* @__PURE__ */ new Map();
+  const perCycle = /* @__PURE__ */ new Map();
   for (const r of recentReports) {
-    const group = perSprint.get(r.sprint) ?? [];
+    const group = perCycle.get(r.cycle) ?? [];
     group.push(r);
-    perSprint.set(r.sprint, group);
+    perCycle.set(r.cycle, 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 sortedCycles = [...perCycle.keys()].sort((a, b) => a - b);
+  for (const cycle of sortedCycles) {
+    const reps = perCycle.get(cycle);
     const deltas = [];
     for (const r of reps) {
       const actual = effortOrdinal(r.actualEffort);
@@ -918,7 +980,7 @@ function calculateSprintMetrics(reports, currentSprint, window = 5) {
     }
     if (deltas.length > 0) {
       accuracy.push({
-        sprint,
+        cycle,
         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,
@@ -926,7 +988,7 @@ function calculateSprintMetrics(reports, currentSprint, window = 5) {
       });
     }
     velocity.push({
-      sprint,
+      cycle,
       completed: reps.filter((r) => r.completed === "Yes").length,
       partial: reps.filter((r) => r.completed === "Partial").length,
       failed: reps.filter((r) => r.completed === "No").length,
@@ -936,23 +998,23 @@ function calculateSprintMetrics(reports, currentSprint, window = 5) {
   return { accuracy, velocity };
 }
 function serializeAccuracyRow(a) {
-  return `| ${a.sprint} | ${a.reports} | ${a.matchRate}% | ${a.mae} | ${a.bias >= 0 ? "+" : ""}${a.bias} |`;
+  return `| ${a.cycle} | ${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} |`;
+  return `| ${v.cycle} | ${v.completed} | ${v.partial} | ${v.failed} | ${v.effortPoints} |`;
 }
 function serializeSnapshot(snapshot) {
   const lines = [];
-  lines.push(`## Sprint ${snapshot.sprint} Snapshot \u2014 ${snapshot.date}`);
+  lines.push(`## Cycle ${snapshot.cycle} Snapshot \u2014 ${snapshot.date}`);
   lines.push("");
-  lines.push("### Estimation Accuracy (last 5 sprints)");
+  lines.push("### Estimation Accuracy (last 5 cycles)");
   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("### Cycle Velocity");
   lines.push(VELOCITY_HEADER);
   lines.push(VELOCITY_SEPARATOR);
   for (const v of snapshot.velocity) {
@@ -965,10 +1027,13 @@ function appendSnapshotToContent(snapshot, content) {
   if (!content.trim()) {
     return FILE_HEADING + "\n\n" + block + "\n";
   }
-  const marker = `## Sprint ${snapshot.sprint} Snapshot`;
-  const markerIdx = content.indexOf(marker);
+  const marker = `## Cycle ${snapshot.cycle} Snapshot`;
+  const legacyMarker = `## Sprint ${snapshot.cycle} Snapshot`;
+  let markerIdx = content.indexOf(marker);
+  if (markerIdx === -1) markerIdx = content.indexOf(legacyMarker);
   if (markerIdx !== -1) {
-    const nextSnapshotIdx = content.indexOf("\n## Sprint ", markerIdx + marker.length);
+    let nextSnapshotIdx = content.indexOf("\n## Cycle ", markerIdx + marker.length);
+    if (nextSnapshotIdx === -1) 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");
@@ -978,12 +1043,12 @@ function appendSnapshotToContent(snapshot, content) {
 function parseSnapshots(content) {
   if (!content.trim()) return [];
   const snapshots = [];
-  const headerRegex = /^## Sprint (\d+) Snapshot — (\S+)/gm;
+  const headerRegex = /^## (?:Cycle|Sprint) (\d+) Snapshot — (\S+)/gm;
   let match;
   const headers = [];
   while ((match = headerRegex.exec(content)) !== null) {
     headers.push({
-      sprint: parseInt(match[1], 10),
+      cycle: parseInt(match[1], 10),
       date: match[2],
       index: match.index
     });
@@ -995,7 +1060,7 @@ function parseSnapshots(content) {
     const accuracy = parseAccuracyTable(block);
     const velocity = parseVelocityTable(block);
     snapshots.push({
-      sprint: headers[i].sprint,
+      cycle: headers[i].cycle,
       date: headers[i].date,
       accuracy,
       velocity
@@ -1011,22 +1076,22 @@ function isRealFinding(text) {
   const trimmed = text.trim();
   return trimmed.length > 0 && !NONE_PATTERN.test(trimmed);
 }
-async function detectBuildPatterns(reports, currentSprint, window = 5, clusterer) {
+async function detectBuildPatterns(reports, currentCycle, window = 5, clusterer) {
   const recentReports = reports.filter(
-    (r) => r.sprint > currentSprint - window && r.sprint <= currentSprint
+    (r) => r.cycle > currentCycle - window && r.cycle <= currentCycle
   );
   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)
+      source: String(r.cycle)
     }));
     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)
+      cycles: [...new Set(c.entries.map((e) => parseInt(e.source, 10)))].sort((a, b) => a - b)
     }));
     recurringSurprises.sort((a, b) => b.count - a.count);
   } else {
@@ -1036,9 +1101,9 @@ async function detectBuildPatterns(reports, currentSprint, window = 5, clusterer
       const existing = surpriseMap.get(key);
       if (existing) {
         existing.count += 1;
-        existing.sprints.add(r.sprint);
+        existing.cycles.add(r.cycle);
       } else {
-        surpriseMap.set(key, { original: r.surprises.trim(), count: 1, sprints: /* @__PURE__ */ new Set([r.sprint]) });
+        surpriseMap.set(key, { original: r.surprises.trim(), count: 1, cycles: /* @__PURE__ */ new Set([r.cycle]) });
       }
     }
     recurringSurprises = [];
@@ -1047,7 +1112,7 @@ async function detectBuildPatterns(reports, currentSprint, window = 5, clusterer
         recurringSurprises.push({
           text: entry.original,
           count: entry.count,
-          sprints: [...entry.sprints].sort((a, b) => a - b)
+          cycles: [...entry.cycles].sort((a, b) => a - b)
         });
       }
     }
@@ -1117,7 +1182,7 @@ function parseAccuracyTable(block) {
     const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
     if (cells.length < 5) continue;
     rows.push({
-      sprint: parseInt(cells[0], 10),
+      cycle: parseInt(cells[0], 10),
       reports: parseInt(cells[1], 10),
       matchRate: parseInt(cells[2].replace("%", ""), 10),
       mae: parseFloat(cells[3]),
@@ -1143,7 +1208,7 @@ function parseVelocityTable(block) {
     const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
     if (cells.length < 5) continue;
     rows.push({
-      sprint: parseInt(cells[0], 10),
+      cycle: parseInt(cells[0], 10),
       completed: parseInt(cells[1], 10),
       partial: parseInt(cells[2], 10),
       failed: parseInt(cells[3], 10),
@@ -1178,12 +1243,12 @@ function parseReviews(content) {
     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 cycle = parseInt(parseField2(block, "Cycle"), 10);
+    if (isNaN(cycle)) 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 review = { uuid: uuidRaw ?? randomUUID5(), ...displayIdRaw ? { displayId: displayIdRaw } : {}, taskId, stage, reviewer, verdict, cycle, date, comments };
     const handoffRevRaw = parseField2(block, "Handoff Revision");
     if (handoffRevRaw) {
       const parsed = parseInt(handoffRevRaw, 10);
@@ -1209,11 +1274,22 @@ function serializeReview(review) {
   lines.push(
     `- **Reviewer:** ${review.reviewer}`,
     `- **Verdict:** ${review.verdict}`,
-    `- **Sprint:** ${review.sprint}`,
+    `- **Cycle:** ${review.cycle}`,
     `- **Comments:** ${review.comments}`
   );
   if (review.handoffRevision !== void 0) lines.push(`- **Handoff Revision:** ${review.handoffRevision}`);
   if (review.buildCommitSha) lines.push(`- **Build Commit SHA:** ${review.buildCommitSha}`);
+  if (review.autoReview) {
+    lines.push("", `#### Auto-Review (${review.autoReview.verdict})`);
+    lines.push(`> ${review.autoReview.summary}`);
+    if (review.autoReview.findings.length > 0) {
+      lines.push("");
+      for (const f of review.autoReview.findings) {
+        const loc = f.file ? f.line ? `${f.file}:${f.line}` : f.file : "";
+        lines.push(`- \`${f.severity}\`${loc ? ` ${loc}` : ""}: ${f.message}`);
+      }
+    }
+  }
   return lines.join("\n");
 }
 function prependReview(review, content) {
@@ -1320,126 +1396,15 @@ ${PHASES_END}`;
   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
+// src/parsers/cycles.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 = {
+var VALID_STATUSES2 = /* @__PURE__ */ new Set(["planning", "active", "complete"]);
+function toCycle(raw) {
+  if (!VALID_STATUSES2.has(raw.status)) return null;
+  const cycle = {
     id: raw.id,
     number: raw.number,
     status: raw.status,
@@ -1448,71 +1413,73 @@ function toSprint(raw) {
     boardHealth: raw.board_health ?? "",
     taskIds: raw.task_ids ?? []
   };
-  if (raw.end_date) sprint.endDate = raw.end_date;
-  return sprint;
+  if (raw.end_date) cycle.endDate = raw.end_date;
+  if (raw.user_id) cycle.userId = raw.user_id;
+  return cycle;
 }
-function fromSprint(sprint) {
+function fromCycle(cycle) {
   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
+    id: cycle.id,
+    number: cycle.number,
+    status: cycle.status,
+    start_date: cycle.startDate,
+    goals: cycle.goals,
+    board_health: cycle.boardHealth,
+    task_ids: cycle.taskIds
   };
-  if (sprint.endDate) raw.end_date = sprint.endDate;
+  if (cycle.endDate) raw.end_date = cycle.endDate;
+  if (cycle.userId) raw.user_id = cycle.userId;
   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");
+  if (markerIdx === -1) throw new Error("PAPI-ADAPTER marker not found in CYCLES.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");
+  if (startIdx === -1) throw new Error("PAPI-YAML-START marker not found in CYCLES.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");
+  if (endIdx === -1) throw new Error("PAPI-YAML-END marker not found in CYCLES.md");
   return afterMarker.slice(yamlStart, endIdx);
 }
-function parseSprints(content) {
+function parseCycles(content) {
   if (!content.trim()) return [];
   const yamlText = extractYamlBlock2(content);
   const data = yaml2.load(yamlText);
-  return (data.sprints ?? []).map(toSprint).filter((s) => s !== null);
+  return (data.cycles ?? []).map(toCycle).filter((s) => s !== null);
 }
-function serializeSprints(sprints, content) {
-  const raw = sprints.map(fromSprint);
-  const yamlStr = yaml2.dump({ sprints: raw }, { lineWidth: 120, quotingType: '"' });
+function serializeCycles(cycles, content) {
+  const raw = cycles.map(fromCycle);
+  const yamlStr = yaml2.dump({ cycles: raw }, { lineWidth: 120, quotingType: '"' });
   const markerIdx = content.indexOf(YAML_MARKER2);
-  if (markerIdx === -1) throw new Error("PAPI-ADAPTER marker not found in SPRINTS.md");
+  if (markerIdx === -1) throw new Error("PAPI-ADAPTER marker not found in CYCLES.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");
+  if (startIdx === -1) throw new Error("PAPI-YAML-START marker not found in CYCLES.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");
+  if (endIdx === -1) throw new Error("PAPI-YAML-END marker not found in CYCLES.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);
+function serializeCycle(cycle) {
+  const raw = fromCycle(cycle);
   return yaml2.dump(raw, { lineWidth: 120, quotingType: '"' }).trim();
 }
-function prependSprint(sprint, content) {
+function prependCycle(cycle, content) {
   if (!content.trim()) {
-    const header = `# Sprints
+    const header = `# Cycles
 
 <!-- PAPI-ADAPTER: parse the yaml block below -->
 
 `;
-    const raw = fromSprint(sprint);
-    const yamlStr = yaml2.dump({ sprints: [raw] }, { lineWidth: 120, quotingType: '"' });
+    const raw = fromCycle(cycle);
+    const yamlStr = yaml2.dump({ cycles: [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);
+  const existing = parseCycles(content);
+  const merged = [cycle, ...existing];
+  return serializeCycles(merged, content);
 }
 
 // src/parsers/registries.ts
@@ -1588,77 +1555,87 @@ var MdFileAdapter = class {
     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). */
+  /** Parse the full planning context into structured sections (reads from PLANNING_LOG.md + ACTIVE_DECISIONS.md + CYCLE_LOG.md). */
   async readPlanningLog() {
-    const [planningContent, activeDecisionsContent, sprintLogContent] = await Promise.all([
+    const [planningContent, activeDecisionsContent, cycleLogContent] = await Promise.all([
       this.read("PLANNING_LOG.md"),
       this.readOptional("ACTIVE_DECISIONS.md"),
       this.readOptional("SPRINT_LOG.md")
     ]);
-    return parsePlanningLog(planningContent, activeDecisionsContent, sprintLogContent);
+    return parsePlanningLog(planningContent, activeDecisionsContent, cycleLogContent);
   }
-  /** Read the Sprint Health table from PLANNING_LOG.md. */
-  async getSprintHealth() {
-    return parseSprintHealth(await this.read("PLANNING_LOG.md"));
+  /** Read the Cycle Health table from PLANNING_LOG.md. */
+  async getCycleHealth() {
+    return parseCycleHealth(await this.read("PLANNING_LOG.md"));
   }
-  /** Read all Active Decisions from ACTIVE_DECISIONS.md. */
-  async getActiveDecisions() {
+  /**
+   * Read Active Decisions from ACTIVE_DECISIONS.md.
+   *
+   * Default filters out retired ADs (outcome ∈ abandoned/superseded/resolved or superseded=true).
+   * Pass { includeRetired: true } for management/triage surfaces. See PapiAdapter docstring.
+   */
+  async getActiveDecisions(options) {
     const content = await this.readOptional("ACTIVE_DECISIONS.md");
     if (!content) return [];
-    return parseActiveDecisions(content);
+    const all = parseActiveDecisions(content);
+    if (options?.includeRetired) return all;
+    return all.filter(isLiveDecision);
   }
-  /** Read sprint log entries (newest first), optionally limited to {@link limit} entries. */
-  async getSprintLog(limit) {
-    return parseSprintLog(await this.read("SPRINT_LOG.md"), limit);
+  /** Read cycle log entries (newest first), optionally limited to {@link limit} entries. */
+  async getCycleLog(limit) {
+    return parseCycleLog(await this.read("SPRINT_LOG.md"), limit);
   }
-  async getSprintLogSince(sprintNumber) {
-    const log = await this.getSprintLog();
-    return log.filter((entry) => entry.sprintNumber >= sprintNumber);
+  async getCycleLogSince(cycleNumber) {
+    const log = await this.getCycleLog();
+    return log.filter((entry) => entry.cycleNumber >= cycleNumber);
   }
-  /** Merge partial updates into the Sprint Health table and write back. */
-  async setSprintHealth(updates) {
+  /** Merge partial updates into the Cycle Health table and write back. */
+  async setCycleHealth(updates) {
     const content = await this.read("PLANNING_LOG.md");
-    const current = parseSprintHealth(content);
+    const current = parseCycleHealth(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() };
-    }
+    await this.write("PLANNING_LOG.md", serializeCycleHealth(updated, content));
+  }
+  /** Prepend a new cycle log entry at the top of the Cycle Log section. */
+  async writeCycleLogEntry(entry) {
+    const patched = {
+      ...entry,
+      uuid: entry.uuid || randomUUID6(),
+      date: entry.date ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
     const content = await this.read("SPRINT_LOG.md");
-    await this.write("SPRINT_LOG.md", prependSprintLogEntry(entry, content));
+    await this.write("SPRINT_LOG.md", prependCycleLogEntry(patched, content));
   }
-  /** Write a strategy review — for md adapter, delegates to sprint log. */
+  /** Write a strategy review — for md adapter, delegates to cycle log. */
   async writeStrategyReview(review) {
-    await this.writeSprintLogEntry({
+    await this.writeCycleLogEntry({
       uuid: randomUUID6(),
-      sprintNumber: review.sprintNumber,
+      cycleNumber: review.cycleNumber,
       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();
+  /** Get the cycle number of the last strategy review. */
+  async getLastStrategyReviewCycle() {
+    const log = await this.getCycleLog();
     const entry = log.find(
       (e) => /strategy.*review|strategic.*shift/i.test(e.title)
     );
-    return entry?.sprintNumber ?? 0;
+    return entry?.cycleNumber ?? 0;
   }
-  /** Get strategy reviews — md adapter returns empty (reviews live in sprint log). */
-  async getStrategyReviews(_limit) {
+  /** Get strategy reviews — md adapter returns empty (reviews live in cycle log). */
+  async getStrategyReviews(_limit, _includeFullAnalysis) {
     return [];
   }
   /** Update or insert an Active Decision block by ID. */
-  async updateActiveDecision(id, body, sprintNumber) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async updateActiveDecision(id, body, cycleNumber, _action) {
     const content = await this.readOptional("ACTIVE_DECISIONS.md") || "## Active Decisions\n\n";
-    await this.write("ACTIVE_DECISIONS.md", updateActiveDecisionInContent(id, body, content, sprintNumber));
+    await this.write("ACTIVE_DECISIONS.md", updateActiveDecisionInContent(id, body, content, cycleNumber));
   }
-  // --- Sprint Board ---
-  /** Query the sprint board, optionally filtering by status/priority/phase/etc. */
+  // --- Cycle Board ---
+  /** Query the cycle 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;
@@ -1714,7 +1691,7 @@ var MdFileAdapter = class {
     const archivedTasks = archiveContent ? parseBoard(archiveContent) : [];
     await this.warnInvalidPhase(task.phase);
     await this.warnInvalidModule(task.module);
-    await this.warnInvalidEpic(task.epic);
+    if (task.epic) 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);
@@ -1783,6 +1760,68 @@ var MdFileAdapter = class {
   async updateTaskStatus(id, status) {
     return this.updateTask(id, { status });
   }
+  /**
+   * task-1763 (C293): atomic compare-and-swap task claim. First-claim-wins —
+   * sets assigneeId only if the task is currently unclaimed. The markdown adapter
+   * is single-process, so the read-check-write is trivially atomic here; the real
+   * concurrency guarantee lives in the pg adapter's RETURNING CAS. Returns the
+   * claimed task, or null if it was already claimed or does not exist.
+   *
+   * task-2071 (MU-3): the pooled-task invariant is `assigneeId == null && cycle
+   * == null` — a task already pulled into someone's cycle is NOT in the pool and
+   * cannot be claimed. Sets claimSource='pool' on success.
+   */
+  async claimTask(taskId, assigneeId) {
+    const content = await this.read("SPRINT_BOARD.md");
+    const tasks = parseBoard(content);
+    const idx = tasks.findIndex((t) => t.id === taskId);
+    if (idx === -1) return null;
+    if (tasks[idx].assigneeId || tasks[idx].cycle != null) return null;
+    tasks[idx] = { ...tasks[idx], assigneeId, claimSource: "pool" };
+    await this.write("SPRINT_BOARD.md", serializeBoard(tasks, content));
+    return tasks[idx];
+  }
+  /**
+   * task-2071 (C293, MU-3): claimer-only release. Clears assigneeId + claimSource
+   * only if the task is currently assigned to `assigneeId` and has not entered
+   * review. Returns the unclaimed task, or null if the caller is not the claimer,
+   * the task has progressed, or it does not exist.
+   */
+  async unclaimTask(taskId, assigneeId) {
+    const content = await this.read("SPRINT_BOARD.md");
+    const tasks = parseBoard(content);
+    const idx = tasks.findIndex((t2) => t2.id === taskId);
+    if (idx === -1) return null;
+    const t = tasks[idx];
+    if (t.assigneeId !== assigneeId) return null;
+    if (t.status === "In Review" || t.status === "Done") return null;
+    const next = { ...t };
+    delete next.assigneeId;
+    delete next.claimSource;
+    tasks[idx] = next;
+    await this.write("SPRINT_BOARD.md", serializeBoard(tasks, content));
+    return tasks[idx];
+  }
+  /**
+   * task-2072 (C293, MU-4): atomic review claim. Sets reviewerId only if the task
+   * is In Review and not yet claimed for review (reviewerId == null). First-claim-
+   * wins. Returns the claimed task, or null if already review-claimed / not In
+   * Review / missing.
+   */
+  async claimReview(taskId, reviewerId) {
+    const content = await this.read("SPRINT_BOARD.md");
+    const tasks = parseBoard(content);
+    const idx = tasks.findIndex((t2) => t2.id === taskId);
+    if (idx === -1) return null;
+    const t = tasks[idx];
+    if (t.status !== "In Review") return null;
+    if (t.reviewerId) return null;
+    tasks[idx] = { ...t, reviewerId };
+    await this.write("SPRINT_BOARD.md", serializeBoard(tasks, content));
+    return tasks[idx];
+  }
+  async recordTransition(_taskId, _fromStatus, _toStatus, _changedBy) {
+  }
   // --- Build Reports ---
   /** Insert a new build report at the top of BUILD_REPORTS.md. */
   async appendBuildReport(report) {
@@ -1810,10 +1849,15 @@ var MdFileAdapter = class {
     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) {
+  /** Return the number of build reports for a specific task. */
+  async getBuildReportCountForTask(taskId) {
     const reports = parseBuildReports(await this.read("BUILD_REPORTS.md"));
-    return reports.filter((r) => r.sprint >= sprintNumber);
+    return reports.filter((r) => r.taskId === taskId).length;
+  }
+  /** Return all build reports from cycles >= {@link cycleNumber}. */
+  async getBuildReportsSince(cycleNumber) {
+    const reports = parseBuildReports(await this.read("BUILD_REPORTS.md"));
+    return reports.filter((r) => r.cycle >= cycleNumber);
   }
   // --- Human Reviews ---
   /** Return recent human reviews from REVIEWS.md (newest first), optionally limited to {@link count}. */
@@ -1845,10 +1889,10 @@ var MdFileAdapter = class {
     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) {
+  /** Compress old cycle log entries below {@link threshold} into a summary block. */
+  async compressCycleLog(threshold, summary) {
     const content = await this.read("SPRINT_LOG.md");
-    await this.write("SPRINT_LOG.md", compressSprintLogInContent(content, threshold, summary));
+    await this.write("SPRINT_LOG.md", compressCycleLogInContent(content, threshold, summary));
   }
   /** Compress old build reports below {@link threshold} into a summary block. */
   async compressBuildReports(threshold, summary) {
@@ -1870,17 +1914,17 @@ var MdFileAdapter = class {
     const { buildHandoff, buildReport, ...rest } = task;
     return rest;
   }
-  /** Append tasks to ARCHIVE_SPRINT_BOARD.md, stripping heavy fields and deduplicating by ID. */
+  /** Append tasks to ARCHIVE_CYCLE_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 archiveContent = existing || "# PAPI Cycle 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. */
+  /** Archive tasks matching phases and/or statuses to ARCHIVE_CYCLE_BOARD.md and remove them from active board. */
   async archiveTasks(phases, statuses) {
     const content = await this.read("SPRINT_BOARD.md");
     const tasks = parseBoard(content);
@@ -1916,6 +1960,11 @@ var MdFileAdapter = class {
   async updateProductBrief(content) {
     await this.write("PRODUCT_BRIEF.md", content);
   }
+  async readDiscoveryCanvas() {
+    return {};
+  }
+  async updateDiscoveryCanvas(_canvas) {
+  }
   /** Read all phases from PHASES.md (falls back to PRODUCT_BRIEF.md for migration). */
   async readPhases() {
     const phasesContent = await this.readOptional("PHASES.md");
@@ -1944,59 +1993,6 @@ ${PHASES_END2}`;
     } 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}
 `);
     }
@@ -2013,15 +2009,14 @@ ${newSection}
     if (!content) return [];
     return parseToolMetrics(content);
   }
-  /** Aggregate tool call metrics into a cost summary, optionally filtered by sprint. */
-  async getCostSummary(sprintNumber) {
+  async hasToolMilestone(name) {
     const metrics = await this.readToolMetrics();
-    return aggregateCostSummary(metrics, sprintNumber);
+    return metrics.some((m) => m.tool === name);
   }
-  /** 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));
+  /** Aggregate tool call metrics into a cost summary, optionally filtered by cycle. */
+  async getCostSummary(cycleNumber) {
+    const metrics = await this.readToolMetrics();
+    return aggregateCostSummary(metrics, cycleNumber);
   }
   /** Read all cost snapshots from the Cost Summary section of METRICS.md. */
   async getCostSnapshots() {
@@ -2029,29 +2024,29 @@ ${newSection}
     if (!content) return [];
     return parseCostSnapshots(content);
   }
-  // --- Sprint Methodology Metrics ---
-  /** Append a sprint metrics snapshot to SPRINT_METRICS.md. */
-  async appendSprintMetrics(snapshot) {
+  // --- Cycle Methodology Metrics ---
+  /** Append a cycle metrics snapshot to CYCLE_METRICS.md. */
+  async appendCycleMetrics(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() {
+  /** Read all cycle metrics snapshots from CYCLE_METRICS.md. */
+  async readCycleMetrics() {
     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");
+  // --- Cycles ---
+  /** Read all Cycle entities from CYCLES.md (newest first). */
+  async readCycles() {
+    const content = await this.readOptional("CYCLES.md");
     if (!content) return [];
-    return parseSprints(content);
+    return parseCycles(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));
+  /** Write a new Cycle entity to CYCLES.md. */
+  async createCycle(cycle) {
+    const content = await this.readOptional("CYCLES.md");
+    await this.write("CYCLES.md", prependCycle(cycle, content));
   }
   // --- Registries ---
   /** Read module and epic registries from REGISTRIES.md. */
@@ -2081,8 +2076,9 @@ ${newSection}
       `    type: ${full.type}`,
       `    status: ${full.status}`,
       `    content: ${JSON.stringify(full.content)}`,
-      `    created_sprint: ${full.createdSprint}`,
-      full.actionedSprint != null ? `    actioned_sprint: ${full.actionedSprint}` : null
+      `    created_sprint: ${full.createdCycle}`,
+      full.actionedCycle != null ? `    actioned_cycle: ${full.actionedCycle}` : null,
+      full.target != null ? `    target: ${JSON.stringify(full.target)}` : null
     ].filter(Boolean).join("\n");
     if (!content) {
       await this.write("STRATEGY_RECOMMENDATIONS.md", `${header}${entry}
@@ -2115,7 +2111,7 @@ ${footer}`);
       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+)/);
+      const actionedMatch = block.match(/actioned_cycle:\s+(\d+)/);
       if (!idMatch || !typeMatch || !statusMatch || !contentMatch || !createdMatch) continue;
       const status = statusMatch[1].trim();
       if (status !== "pending") continue;
@@ -2131,29 +2127,125 @@ ${footer}`);
         type: typeMatch[1].trim(),
         status: "pending",
         content: parsedContent,
-        createdSprint: parseInt(createdMatch[1], 10),
-        actionedSprint: actionedMatch ? parseInt(actionedMatch[1], 10) : void 0
+        createdCycle: parseInt(createdMatch[1], 10),
+        actionedCycle: actionedMatch ? parseInt(actionedMatch[1], 10) : void 0
       });
     }
     return recs;
   }
   /** Mark a recommendation as actioned. */
-  async actionRecommendation(id, sprintNumber) {
+  async actionRecommendation(id, cycleNumber) {
     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}
+    if (entryMatch && !entryMatch[0].includes("actioned_cycle:")) {
+      const cyclePattern = new RegExp(`(\\s+-\\s+id:\\s+${id}\\n(?:.*\\n)*?\\s+created_sprint:\\s+\\d+)\\n`);
+      updated = updated.replace(cyclePattern, `$1
+    actioned_cycle: ${cycleNumber}
 `);
     }
     await this.write("STRATEGY_RECOMMENDATIONS.md", updated);
   }
   // -------------------------------------------------------------------------
+  // Strategy Review Agenda (markdown persistence)
+  // -------------------------------------------------------------------------
+  async addAgendaTopic(input) {
+    const id = randomUUID6();
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const full = {
+      id,
+      topic: input.topic,
+      source: input.source,
+      sourceCycle: input.sourceCycle,
+      status: "pending",
+      createdAt
+    };
+    const content = await this.readOptional("STRATEGY_REVIEW_AGENDA.md");
+    const header = "# Strategy Review Agenda\n\n<!-- PAPI-ADAPTER: parse the yaml block below -->\n\n<!-- PAPI-YAML-START -->\ntopics:\n";
+    const footer = "<!-- PAPI-YAML-END -->\n";
+    const entry = [
+      `  - id: ${full.id}`,
+      `    topic: ${JSON.stringify(full.topic)}`,
+      `    source: ${full.source}`,
+      full.sourceCycle != null ? `    source_cycle: ${full.sourceCycle}` : null,
+      `    status: ${full.status}`,
+      `    created_at: ${full.createdAt}`
+    ].filter(Boolean).join("\n");
+    if (!content) {
+      await this.write("STRATEGY_REVIEW_AGENDA.md", `${header}${entry}
+${footer}`);
+    } else {
+      const insertPoint = content.indexOf("<!-- PAPI-YAML-END -->");
+      if (insertPoint === -1) {
+        await this.write("STRATEGY_REVIEW_AGENDA.md", `${header}${entry}
+${footer}`);
+      } else {
+        const updated = content.slice(0, insertPoint) + entry + "\n" + content.slice(insertPoint);
+        await this.write("STRATEGY_REVIEW_AGENDA.md", updated);
+      }
+    }
+    return full;
+  }
+  async getPendingAgendaTopics() {
+    const content = await this.readOptional("STRATEGY_REVIEW_AGENDA.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 topics = [];
+    for (const block of entries) {
+      const idMatch = block.match(/id:\s+(.+)/);
+      const topicMatch = block.match(/topic:\s+(.+)/);
+      const sourceMatch = block.match(/source:\s+(\S+)/);
+      const statusMatch = block.match(/status:\s+(\S+)/);
+      const createdMatch = block.match(/created_at:\s+(.+)/);
+      const sourceCycleMatch = block.match(/source_cycle:\s+(\d+)/);
+      if (!idMatch || !topicMatch || !sourceMatch || !statusMatch || !createdMatch) continue;
+      if (statusMatch[1].trim() !== "pending") continue;
+      let parsedTopic = topicMatch[1].trim();
+      if (parsedTopic.startsWith('"') && parsedTopic.endsWith('"')) {
+        try {
+          parsedTopic = JSON.parse(parsedTopic);
+        } catch {
+        }
+      }
+      topics.push({
+        id: idMatch[1].trim(),
+        topic: parsedTopic,
+        source: sourceMatch[1].trim(),
+        sourceCycle: sourceCycleMatch ? parseInt(sourceCycleMatch[1], 10) : void 0,
+        status: "pending",
+        createdAt: createdMatch[1].trim()
+      });
+    }
+    return topics;
+  }
+  async markAgendaTopicsAddressed(ids, cycleNumber) {
+    if (ids.length === 0) return;
+    const content = await this.readOptional("STRATEGY_REVIEW_AGENDA.md");
+    if (!content) return;
+    let updated = content;
+    const addressedAt = (/* @__PURE__ */ new Date()).toISOString();
+    for (const id of ids) {
+      const statusPattern = new RegExp(`(\\s+-\\s+id:\\s+${id}\\n(?:.*\\n)*?\\s+status:\\s+)pending`);
+      updated = updated.replace(statusPattern, `$1addressed`);
+      const insertionAnchor = new RegExp(`(\\s+-\\s+id:\\s+${id}\\n(?:.*\\n)*?\\s+created_at:\\s+[^\\n]+)\\n`);
+      const match = updated.match(insertionAnchor);
+      if (match && !match[0].includes("addressed_at:")) {
+        updated = updated.replace(insertionAnchor, `$1
+    addressed_at: ${addressedAt}
+    addressed_in_review: ${cycleNumber}
+`);
+      }
+    }
+    await this.write("STRATEGY_REVIEW_AGENDA.md", updated);
+  }
+  // -------------------------------------------------------------------------
   // Decision Events & Scores (markdown persistence)
   // -------------------------------------------------------------------------
   async appendDecisionEvent(event) {
@@ -2162,11 +2254,13 @@ ${footer}`);
     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}
+    const entry = `## ${full.decisionId} | ${full.eventType} | Cycle ${full.cycle}
 - **id:** ${full.id}
 - **source:** ${full.source}
 ` + (full.sourceRef ? `- **sourceRef:** ${full.sourceRef}
 ` : "") + (full.detail ? `- **detail:** ${full.detail}
+` : "") + (full.evidenceRef ? `- **evidenceRef:** ${full.evidenceRef}
+` : "") + (full.metricDelta ? `- **metricDelta:** ${JSON.stringify(full.metricDelta)}
 ` : "") + `- **createdAt:** ${full.createdAt}
 
 ---
@@ -2184,9 +2278,9 @@ ${footer}`);
     const filtered = all.filter((e) => e.decisionId === decisionId);
     return limit ? filtered.slice(0, limit) : filtered;
   }
-  async getDecisionEventsSince(sprint) {
+  async getDecisionEventsSince(cycle) {
     const all = await this.parseDecisionEvents();
-    return all.filter((e) => e.sprint >= sprint);
+    return all.filter((e) => e.cycle >= cycle);
   }
   async parseDecisionEvents() {
     const content = await this.readOptional("DECISION_EVENTS.md");
@@ -2194,22 +2288,34 @@ ${footer}`);
     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);
+      const headingMatch = block.match(/^##\s+(\S+)\s+\|\s+(\S+)\s+\|\s+Cycle\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 evidenceRefMatch = block.match(/\*\*evidenceRef:\*\*\s+(.+)/);
+      const metricDeltaMatch = block.match(/\*\*metricDelta:\*\*\s+(.+)/);
       const createdAtMatch = block.match(/\*\*createdAt:\*\*\s+(.+)/);
       if (!idMatch || !sourceMatch || !createdAtMatch) continue;
+      let metricDelta;
+      if (metricDeltaMatch?.[1]) {
+        try {
+          metricDelta = JSON.parse(metricDeltaMatch[1].trim());
+        } catch {
+          metricDelta = null;
+        }
+      }
       events.push({
         id: idMatch[1].trim(),
         decisionId: headingMatch[1],
         eventType: headingMatch[2],
-        sprint: parseInt(headingMatch[3], 10),
+        cycle: parseInt(headingMatch[3], 10),
         source: sourceMatch[1].trim(),
         sourceRef: sourceRefMatch?.[1]?.trim(),
         detail: detailMatch?.[1]?.trim(),
+        evidenceRef: evidenceRefMatch?.[1]?.trim(),
+        metricDelta,
         createdAt: createdAtMatch[1].trim()
       });
     }
@@ -2222,7 +2328,7 @@ ${footer}`);
     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}
+    const entry = `## ${full.decisionId} | Cycle ${full.cycle}
 - **id:** ${full.id}
 - **effort:** ${full.effort}
 - **risk:** ${full.risk}
@@ -2252,7 +2358,7 @@ ${footer}`);
     const latest = /* @__PURE__ */ new Map();
     for (const s of all) {
       const existing = latest.get(s.decisionId);
-      if (!existing || s.sprint > existing.sprint) {
+      if (!existing || s.cycle > existing.cycle) {
         latest.set(s.decisionId, s);
       }
     }
@@ -2264,7 +2370,7 @@ ${footer}`);
     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);
+      const headingMatch = block.match(/^##\s+(\S+)\s+\|\s+Cycle\s+(\d+)/m);
       if (!headingMatch) continue;
       const field = (name) => block.match(new RegExp(`\\*\\*${name}:\\*\\*\\s+(.+)`))?.[1]?.trim();
       const id = field("id");
@@ -2273,7 +2379,7 @@ ${footer}`);
       scores.push({
         id,
         decisionId: headingMatch[1],
-        sprint: parseInt(headingMatch[2], 10),
+        cycle: parseInt(headingMatch[2], 10),
         effort: parseInt(field("effort") ?? "0", 10),
         risk: parseInt(field("risk") ?? "0", 10),
         reversibility: parseInt(field("reversibility") ?? "0", 10),
@@ -2289,9 +2395,26 @@ ${footer}`);
   // Entity reference tracking — no-op for md adapter (DB-only feature)
   async logEntityReferences(_refs) {
   }
-  async getDecisionUsage(_currentSprint) {
+  async getDecisionUsage(_currentCycle) {
     return [];
   }
+  // --- North Star ---
+  async getCurrentNorthStar() {
+    const content = await this.read("PLANNING_LOG.md");
+    const ns = parseNorthStar(content);
+    return ns || null;
+  }
+  async getNorthStarSetCycle() {
+    return null;
+  }
+  async getNorthStarStaleness() {
+    return null;
+  }
+  async upsertNorthStar(statement, _cycleNumber) {
+    const content = await this.read("PLANNING_LOG.md");
+    const updated = upsertNorthStarInContent(content, statement);
+    await this.write("PLANNING_LOG.md", updated);
+  }
 };
 
 // src/parsers/review-patterns.ts
@@ -2303,9 +2426,9 @@ function isRealComment(text) {
   const trimmed = text.trim();
   return trimmed.length > 0 && !NONE_PATTERN2.test(trimmed);
 }
-async function detectReviewPatterns(reviews, currentSprint, window = 5, clusterer) {
+async function detectReviewPatterns(reviews, currentCycle, window = 5, clusterer) {
   const recentReviews = reviews.filter(
-    (r) => r.sprint > currentSprint - window && r.sprint <= currentSprint
+    (r) => r.cycle > currentCycle - window && r.cycle <= currentCycle
   );
   let recurringFeedback;
   const realComments = recentReviews.filter((r) => isRealComment(r.comments));
@@ -2367,7 +2490,7 @@ export {
   VALID_TRANSITIONS,
   aggregateCostSummary,
   appendToolMetricToContent,
-  calculateSprintMetrics,
+  calculateCycleMetrics,
   detectBuildPatterns,
   detectReviewPatterns,
   hasBuildPatterns,
@@ -2375,24 +2498,21 @@ export {
   isValidStatus,
   isValidTransition,
   parseBuildHandoff,
+  parseCycles,
   parseEffortSize,
-  parseFeatures,
   parsePhases,
   parseRegistries,
   parseReviews,
-  parseSprints,
   parseToolMetrics,
+  prependCycle,
   prependReview,
-  prependSprint,
   serializeBuildHandoff,
-  serializeFeatures,
+  serializeCycle,
+  serializeCycles,
   serializePhases,
   serializeRegistries,
   serializeReview,
-  serializeSprint,
-  serializeSprints,
   serializeToolMetric,
   validateTransition,
-  writeFeaturesToContent,
   writePhasesToContent
 };