@papi-ai/server 0.7.34 → 0.7.35

package/dist/backfill-cycle-metrics.js

@@ -0,0 +1,4329 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/git.ts
+var git_exports = {};
+__export(git_exports, {
+  AUTO_WRITTEN_PATHS: () => AUTO_WRITTEN_PATHS,
+  branchExists: () => branchExists,
+  checkoutBranch: () => checkoutBranch,
+  commitStagedOnly: () => commitStagedOnly,
+  createAndCheckoutBranch: () => createAndCheckoutBranch,
+  createPullRequest: () => createPullRequest,
+  createTag: () => createTag,
+  cycleBranchName: () => cycleBranchName,
+  deleteLocalBranch: () => deleteLocalBranch,
+  detectBoardMismatches: () => detectBoardMismatches,
+  detectUnrecordedCommits: () => detectUnrecordedCommits,
+  ensureLatestDevelop: () => ensureLatestDevelop,
+  ensureTagAtHead: () => ensureTagAtHead,
+  getBranchDiff: () => getBranchDiff,
+  getCommitsSinceTag: () => getCommitsSinceTag,
+  getCurrentBranch: () => getCurrentBranch,
+  getDocPathsTouchedOnBranch: () => getDocPathsTouchedOnBranch,
+  getFilesChangedBetween: () => getFilesChangedBetween,
+  getFilesChangedFromBase: () => getFilesChangedFromBase,
+  getHeadCommitSha: () => getHeadCommitSha,
+  getHeadCommitSubject: () => getHeadCommitSubject,
+  getLastCommitFiles: () => getLastCommitFiles,
+  getLatestTag: () => getLatestTag,
+  getModifiedFiles: () => getModifiedFiles,
+  getOriginRepoSlug: () => getOriginRepoSlug,
+  getOriginUrl: () => getOriginUrl,
+  getPullRequestUrl: () => getPullRequestUrl,
+  getRemoteBranchFiles: () => getRemoteBranchFiles,
+  getRootCommitHash: () => getRootCommitHash,
+  getStagedFiles: () => getStagedFiles,
+  getTagTarget: () => getTagTarget,
+  getTaskIdsOnBranch: () => getTaskIdsOnBranch,
+  getUnmergedBranches: () => getUnmergedBranches,
+  getUntrackedFiles: () => getUntrackedFiles,
+  gitPull: () => gitPull,
+  gitPush: () => gitPush,
+  hasRemote: () => hasRemote,
+  hasUncommittedChanges: () => hasUncommittedChanges,
+  hasUnpushedCommits: () => hasUnpushedCommits,
+  isBranchMergedInto: () => isBranchMergedInto,
+  isGhAvailable: () => isGhAvailable,
+  isGitAvailable: () => isGitAvailable,
+  isGitRepo: () => isGitRepo,
+  listGroupedCycleBranches: () => listGroupedCycleBranches,
+  listOrphanFeatBranches: () => listOrphanFeatBranches,
+  mergePullRequest: () => mergePullRequest,
+  normalizeGitUrl: () => normalizeGitUrl,
+  pickModuleCycleBranch: () => pickModuleCycleBranch,
+  resolveBaseBranch: () => resolveBaseBranch,
+  runAutoCommit: () => runAutoCommit,
+  squashMergePullRequest: () => squashMergePullRequest,
+  stageAllAndCommit: () => stageAllAndCommit,
+  stageDirAndCommit: () => stageDirAndCommit,
+  stagePathsAndCommit: () => stagePathsAndCommit,
+  tagExists: () => tagExists,
+  taskBranchName: () => taskBranchName,
+  withBaseBranchSync: () => withBaseBranchSync
+});
+import { execFileSync } from "child_process";
+function isGitAvailable() {
+  try {
+    execFileSync("git", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGitRepo(cwd) {
+  try {
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function stageDirAndCommit(cwd, dir, message) {
+  try {
+    execFileSync("git", ["check-ignore", "-q", dir], { cwd });
+    return { committed: false, message: `Skipped commit \u2014 '${dir}' is gitignored.` };
+  } catch {
+  }
+  execFileSync("git", ["add", dir], { cwd });
+  const staged = execFileSync("git", ["diff", "--cached", "--name-only"], {
+    cwd,
+    encoding: "utf-8"
+  }).trim();
+  if (!staged) {
+    return { committed: false, message: "No changes to commit." };
+  }
+  execFileSync("git", ["commit", "-m", message], { cwd, encoding: "utf-8" });
+  return { committed: true, message };
+}
+function stageAllAndCommit(cwd, message) {
+  execFileSync("git", ["add", "."], { cwd });
+  const staged = execFileSync("git", ["diff", "--cached", "--name-only"], {
+    cwd,
+    encoding: "utf-8"
+  }).trim();
+  if (!staged) {
+    return { committed: false, message: "No changes to commit." };
+  }
+  execFileSync("git", ["commit", "-m", message], { cwd, encoding: "utf-8" });
+  return { committed: true, message };
+}
+function commitStagedOnly(cwd, message) {
+  const staged = execFileSync("git", ["diff", "--cached", "--name-only"], {
+    cwd,
+    encoding: "utf-8"
+  }).trim();
+  if (!staged) {
+    return { committed: false, message: "No staged changes to commit." };
+  }
+  execFileSync("git", ["commit", "-m", message], { cwd, encoding: "utf-8" });
+  return { committed: true, message };
+}
+function stagePathsAndCommit(cwd, paths, message) {
+  if (paths.length === 0) {
+    return { committed: false, message: "No paths to commit." };
+  }
+  execFileSync("git", ["add", "--", ...paths], { cwd });
+  const staged = execFileSync("git", ["diff", "--cached", "--name-only"], {
+    cwd,
+    encoding: "utf-8"
+  }).trim();
+  if (!staged) {
+    return { committed: false, message: "No changes to commit." };
+  }
+  execFileSync("git", ["commit", "-m", message], { cwd, encoding: "utf-8" });
+  return { committed: true, message };
+}
+function getStagedFiles(cwd) {
+  try {
+    const out = execFileSync("git", ["diff", "--cached", "--name-only"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+    if (!out) return [];
+    return out.split("\n").filter((l) => l.length > 0);
+  } catch {
+    return [];
+  }
+}
+function getModifiedFiles(cwd) {
+  try {
+    const out = execFileSync("git", ["status", "--porcelain"], {
+      cwd,
+      encoding: "utf-8"
+    }).replace(/\n+$/, "");
+    if (!out) return [];
+    const paths = /* @__PURE__ */ new Set();
+    for (const line of out.split("\n")) {
+      if (line.length < 4) continue;
+      const path3 = line.slice(3).trim();
+      if (path3) paths.add(path3);
+    }
+    return Array.from(paths);
+  } catch {
+    return [];
+  }
+}
+function getUntrackedFiles(cwd) {
+  try {
+    const out = execFileSync("git", ["ls-files", "--others", "--exclude-standard"], {
+      cwd,
+      encoding: "utf-8"
+    }).replace(/\n+$/, "");
+    if (!out) return [];
+    return out.split("\n").map((l) => l.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function getBranchDiff(cwd, base = "origin/main", maxBytes = 2e5) {
+  const refs = [`${base}...HEAD`, "main...HEAD"];
+  for (const ref of refs) {
+    try {
+      const out = execFileSync("git", ["diff", ref], {
+        cwd,
+        encoding: "utf-8",
+        maxBuffer: 32 * 1024 * 1024
+      });
+      if (out) {
+        return out.length > maxBytes ? `${out.slice(0, maxBytes)}
+
+... [diff truncated at ${Math.round(maxBytes / 1024)} KB]` : out;
+      }
+      return "";
+    } catch {
+    }
+  }
+  return "";
+}
+function getHeadCommitSubject(cwd) {
+  try {
+    const out = execFileSync("git", ["log", "-1", "--format=%s"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+function getCurrentBranch(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function hasUncommittedChanges(cwd, ignore) {
+  try {
+    const args = ["status", "--porcelain"];
+    if (ignore?.length) {
+      args.push("--", ".", ...ignore.map((p) => `:!${p}`));
+    }
+    const status = execFileSync("git", args, {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+    return status.length > 0;
+  } catch {
+    return false;
+  }
+}
+function branchExists(cwd, branch) {
+  try {
+    execFileSync("git", ["rev-parse", "--verify", branch], {
+      cwd,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkoutBranch(cwd, branch) {
+  try {
+    execFileSync("git", ["checkout", branch], { cwd, encoding: "utf-8" });
+    return { success: true, message: `Checked out branch '${branch}'.` };
+  } catch {
+    return { success: false, message: `Failed to checkout branch '${branch}'.` };
+  }
+}
+function createAndCheckoutBranch(cwd, branch) {
+  try {
+    execFileSync("git", ["checkout", "-b", branch], { cwd, encoding: "utf-8" });
+    return { success: true, message: `Created and checked out branch '${branch}'.` };
+  } catch {
+    return { success: false, message: `Failed to create branch '${branch}'.` };
+  }
+}
+function hasRemote(cwd, remote = "origin") {
+  try {
+    const remotes = execFileSync("git", ["remote"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+    return remotes.split("\n").includes(remote);
+  } catch {
+    return false;
+  }
+}
+function gitPull(cwd) {
+  try {
+    execFileSync("git", ["pull"], { cwd, encoding: "utf-8", timeout: GIT_NETWORK_TIMEOUT_MS });
+    return { success: true, message: "Pulled latest changes." };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const isTimeout = msg.includes("ETIMEDOUT") || msg.includes("killed");
+    return {
+      success: false,
+      message: isTimeout ? "Pull timed out after 30s." : `Pull failed: ${msg}`
+    };
+  }
+}
+function gitPush(cwd, branch) {
+  try {
+    execFileSync("git", ["push", "-u", "origin", branch], {
+      cwd,
+      encoding: "utf-8",
+      timeout: GIT_NETWORK_TIMEOUT_MS
+    });
+    return { success: true, message: `Pushed branch '${branch}' to origin.` };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const isTimeout = msg.includes("ETIMEDOUT") || msg.includes("killed");
+    return {
+      success: false,
+      message: isTimeout ? `Push timed out after 30s.` : `Push failed: ${msg}`
+    };
+  }
+}
+function isGhAvailable() {
+  try {
+    execFileSync("gh", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getOriginRepoSlug(cwd) {
+  try {
+    const url = execFileSync("git", ["remote", "get-url", "origin"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+    const sshMatch = url.match(/github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (sshMatch) return sshMatch[1];
+    const httpsMatch = url.match(/github\.com\/([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (httpsMatch) return httpsMatch[1];
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getRootCommitHash(cwd) {
+  try {
+    const hash = execFileSync("git", ["rev-list", "--max-parents=0", "HEAD"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+    return hash || null;
+  } catch {
+    return null;
+  }
+}
+function getOriginUrl(cwd) {
+  try {
+    const url = execFileSync("git", ["remote", "get-url", "origin"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+function normalizeGitUrl(url) {
+  if (!url) return null;
+  const normalized = url.trim();
+  const sshMatch = normalized.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return `https://${sshMatch[1]}/${sshMatch[2]}`;
+  }
+  const sshProtoMatch = normalized.match(/^ssh:\/\/git@([^/]+)\/(.+?)(?:\.git)?$/);
+  if (sshProtoMatch) {
+    return `https://${sshProtoMatch[1]}/${sshProtoMatch[2]}`;
+  }
+  if (normalized.startsWith("https://") || normalized.startsWith("http://")) {
+    return normalized.replace(/\.git$/, "");
+  }
+  return null;
+}
+function createPullRequest(cwd, branch, baseBranch, title, body) {
+  try {
+    const args = ["pr", "create", "--base", baseBranch, "--head", branch, "--title", title, "--body", body];
+    const repo = getOriginRepoSlug(cwd);
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    const output = execFileSync("gh", args, { cwd, encoding: "utf-8" }).trim();
+    return { success: true, message: output };
+  } catch (err) {
+    return {
+      success: false,
+      message: `PR creation failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function mergePullRequest(cwd, branch) {
+  const repo = getOriginRepoSlug(cwd);
+  const baseArgs = ["pr", "merge", branch, "--merge", "--delete-branch"];
+  if (repo) {
+    baseArgs.push("--repo", repo);
+  }
+  for (let attempt = 1; attempt <= MERGE_MAX_RETRIES; attempt++) {
+    try {
+      execFileSync("gh", baseArgs, { cwd, encoding: "utf-8" });
+      return { success: true, message: `Merged PR for '${branch}' and deleted branch.` };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const isNotMergeable = msg.includes("not mergeable");
+      if (isNotMergeable && attempt < MERGE_MAX_RETRIES) {
+        sleepSync(MERGE_RETRY_DELAY_MS);
+        continue;
+      }
+      return { success: false, message: `PR merge failed: ${msg}` };
+    }
+  }
+  return { success: false, message: "PR merge failed: max retries exceeded" };
+}
+function deleteLocalBranch(cwd, branch) {
+  try {
+    execFileSync("git", ["branch", "-d", branch], { cwd, encoding: "utf-8" });
+    return { success: true, message: `Deleted local branch '${branch}'.` };
+  } catch (err) {
+    return {
+      success: false,
+      message: `Failed to delete local branch '${branch}': ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function tagExists(cwd, tag) {
+  try {
+    execFileSync("git", ["rev-parse", "--verify", `refs/tags/${tag}`], {
+      cwd,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createTag(cwd, tag, message) {
+  try {
+    execFileSync("git", ["tag", "-a", tag, "-m", message], { cwd, encoding: "utf-8" });
+    return { success: true, message: `Created tag '${tag}'.` };
+  } catch (err) {
+    return {
+      success: false,
+      message: `Failed to create tag: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function getTagTarget(cwd, tag) {
+  try {
+    return execFileSync("git", ["rev-parse", `${tag}^{commit}`], {
+      cwd,
+      encoding: "utf-8"
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function ensureTagAtHead(cwd, tag, message) {
+  if (!tagExists(cwd, tag)) {
+    return createTag(cwd, tag, message);
+  }
+  const target = getTagTarget(cwd, tag);
+  const head = getHeadCommitSha(cwd);
+  if (target && head && target === head) {
+    return {
+      success: true,
+      message: `Tag '${tag}' already exists at the current commit \u2014 continuing (partial-release recovery).`
+    };
+  }
+  return {
+    success: false,
+    message: `tag "${tag}" already exists but points at ${target ? target.slice(0, 7) : "an unknown commit"}, not the current HEAD (${head ? head.slice(0, 7) : "unknown"}). If it is left over from an aborted release, delete it and re-run release: \`git tag -d ${tag}\` (and \`git push origin :refs/tags/${tag}\` if it was pushed). Otherwise use a different version.`
+  };
+}
+function getLatestTag(cwd) {
+  try {
+    return execFileSync("git", ["describe", "--tags", "--abbrev=0"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function getCommitsSinceTag(cwd, tag) {
+  try {
+    const output = execFileSync(
+      "git",
+      ["log", `${tag}..HEAD`, "--oneline"],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    return output ? output.split("\n") : [];
+  } catch {
+    return [];
+  }
+}
+function getTaskIdsOnBranch(cwd, branch, baseBranch) {
+  try {
+    const output = execFileSync(
+      "git",
+      ["log", `${baseBranch}..${branch}`, "--format=%s"],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    if (!output) return [];
+    const ids = /* @__PURE__ */ new Set();
+    const taskIdRe = /\((task-\d+)\)/g;
+    for (const subject of output.split("\n")) {
+      let match;
+      while ((match = taskIdRe.exec(subject)) !== null) {
+        ids.add(match[1]);
+      }
+    }
+    return Array.from(ids);
+  } catch {
+    return [];
+  }
+}
+function getDocPathsTouchedOnBranch(cwd, branch, baseBranch) {
+  try {
+    const output = execFileSync(
+      "git",
+      [
+        "log",
+        `${baseBranch}..${branch}`,
+        "--name-only",
+        "--pretty=format:",
+        "--",
+        "CLAUDE.md",
+        "**/CLAUDE.md",
+        "docs/**"
+      ],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    if (!output) return [];
+    const paths = /* @__PURE__ */ new Set();
+    for (const line of output.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.length > 0) paths.add(trimmed);
+    }
+    return Array.from(paths);
+  } catch {
+    return [];
+  }
+}
+async function withBaseBranchSync(config, fn) {
+  const warnings = [];
+  if (!isGitAvailable() || !isGitRepo(config.projectRoot)) {
+    return { result: await fn(), warnings };
+  }
+  const baseBranch = resolveBaseBranch(config.projectRoot, config.baseBranch);
+  if (baseBranch !== config.baseBranch) {
+    warnings.push(`Base branch '${config.baseBranch}' not found \u2014 using '${baseBranch}'.`);
+  }
+  const currentBranch = getCurrentBranch(config.projectRoot);
+  const needsBranchSwitch = currentBranch !== null && currentBranch !== baseBranch;
+  let previousBranch = null;
+  if (needsBranchSwitch && hasUncommittedChanges(config.projectRoot, AUTO_WRITTEN_PATHS)) {
+    warnings.push("Skipping pull \u2014 uncommitted changes detected. Board data may be stale.");
+  } else if (needsBranchSwitch) {
+    const checkout = checkoutBranch(config.projectRoot, baseBranch);
+    if (!checkout.success) {
+      warnings.push(`Could not switch to ${baseBranch}: ${checkout.message} Board data may be stale.`);
+    } else {
+      previousBranch = currentBranch;
+      if (hasRemote(config.projectRoot)) {
+        const pull = gitPull(config.projectRoot);
+        if (!pull.success && config.abortOnConflict && /conflict/i.test(pull.message)) {
+          checkoutBranch(config.projectRoot, previousBranch);
+          return { result: void 0, warnings, abort: pull.message };
+        }
+        warnings.push(pull.success ? `Synced from ${baseBranch}.` : `Pull failed: ${pull.message}`);
+      }
+    }
+  } else if (hasRemote(config.projectRoot)) {
+    const pull = gitPull(config.projectRoot);
+    if (!pull.success && config.abortOnConflict && /conflict/i.test(pull.message)) {
+      return { result: void 0, warnings, abort: pull.message };
+    }
+    warnings.push(pull.success ? `Synced from ${baseBranch}.` : `Pull failed: ${pull.message}`);
+  }
+  const result = await fn();
+  if (previousBranch) {
+    checkoutBranch(config.projectRoot, previousBranch);
+  }
+  return { result, warnings };
+}
+function hasUnpushedCommits(cwd) {
+  try {
+    const output = execFileSync(
+      "git",
+      ["rev-list", "@{u}..HEAD", "--count"],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    return parseInt(output, 10) > 0;
+  } catch {
+    return false;
+  }
+}
+function ensureLatestDevelop(cwd, baseBranch) {
+  if (!isGitAvailable() || !isGitRepo(cwd)) {
+    return { pulled: false };
+  }
+  const current = getCurrentBranch(cwd);
+  if (!current || current !== baseBranch) {
+    return { pulled: false, warning: `Skipping pull \u2014 not on ${baseBranch} (on ${current ?? "unknown"}).` };
+  }
+  if (hasUncommittedChanges(cwd, AUTO_WRITTEN_PATHS)) {
+    return { pulled: false, warning: "Skipping pull \u2014 uncommitted changes detected." };
+  }
+  if (hasUnpushedCommits(cwd)) {
+    return { pulled: false, warning: "Skipping pull \u2014 unpushed commits on current branch." };
+  }
+  if (!hasRemote(cwd)) {
+    return { pulled: false };
+  }
+  const result = gitPull(cwd);
+  if (!result.success) {
+    return { pulled: false, warning: `Pull failed \u2014 using local data. ${result.message}` };
+  }
+  return { pulled: true };
+}
+function getUnmergedBranches(cwd, baseBranch) {
+  try {
+    const output = execFileSync(
+      "git",
+      ["branch", "--no-merged", baseBranch],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    if (!output) return [];
+    return output.split("\n").map((b) => b.replace(/^\*?\s+/, "").trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function resolveBaseBranch(cwd, preferred) {
+  if (branchExists(cwd, preferred)) return preferred;
+  if (preferred !== "main" && branchExists(cwd, "main")) return "main";
+  if (preferred !== "master" && branchExists(cwd, "master")) return "master";
+  return preferred;
+}
+function detectBoardMismatches(cwd, tasks) {
+  const empty = { codeAhead: [], staleInProgress: [] };
+  if (!isGitAvailable() || !isGitRepo(cwd)) return empty;
+  try {
+    const mergedOutput = execFileSync("git", ["branch", "--merged", "HEAD"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const allOutput = execFileSync("git", ["branch"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const parseBranches = (raw) => new Set(raw.split("\n").map((l) => l.trim().replace(/^\* /, "")).filter(Boolean));
+    const mergedBranches = parseBranches(mergedOutput);
+    const allBranches = parseBranches(allOutput);
+    const codeAhead = [];
+    const staleInProgress = [];
+    for (const task of tasks) {
+      const branch = `feat/${task.displayId}`;
+      if (task.status === "Backlog" && mergedBranches.has(branch)) {
+        codeAhead.push({ displayId: task.displayId, title: task.title, branch });
+      }
+      if (task.status === "In Progress" && !allBranches.has(branch)) {
+        staleInProgress.push({ displayId: task.displayId, title: task.title });
+      }
+    }
+    return { codeAhead, staleInProgress };
+  } catch {
+    return empty;
+  }
+}
+function detectUnrecordedCommits(cwd, baseBranch) {
+  if (!isGitAvailable() || !isGitRepo(cwd)) return [];
+  const latestTag = getLatestTag(cwd);
+  if (!latestTag) return [];
+  try {
+    const output = execFileSync(
+      "git",
+      ["log", `${latestTag}..${baseBranch}`, "--oneline", "--max-count=20"],
+      { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+    if (!output) return [];
+    const CYCLE_PATTERNS = [
+      /feat\(task-\d+\):/,
+      // build_execute commits: feat(task-NNN): title
+      /^[a-f0-9]+ release:/,
+      // release commits
+      /^[a-f0-9]+ Merge /,
+      // merge commits from PRs
+      /chore\(task-/,
+      // task-related housekeeping
+      /chore: dogfood log/
+      // automated dogfood log entries post-release
+    ];
+    return output.split("\n").filter((line) => line.trim() && !CYCLE_PATTERNS.some((p) => p.test(line))).map((line) => {
+      const spaceIdx = line.indexOf(" ");
+      return {
+        hash: line.slice(0, spaceIdx),
+        message: line.slice(spaceIdx + 1)
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+function taskBranchName(taskId) {
+  return `feat/${taskId}`;
+}
+function cycleBranchName(cycleNumber, module) {
+  const slug = module.toLowerCase().replace(/&amp;/g, "and").replace(/&/g, "and").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `feat/cycle-${cycleNumber}-${slug}`;
+}
+function getHeadCommitSha(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8" }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function runAutoCommit(projectRoot, commitFn) {
+  if (!isGitAvailable()) return "Auto-commit: skipped (git not found).";
+  if (!isGitRepo(projectRoot)) return "Auto-commit: skipped (not a git repository).";
+  try {
+    const result = commitFn();
+    return result.committed ? `Auto-committed: ${result.message}` : `Auto-commit: ${result.message}`;
+  } catch (err) {
+    return `Auto-commit failed: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+function getPullRequestUrl(cwd, branch) {
+  try {
+    const output = execFileSync(
+      "gh",
+      ["pr", "view", branch, "--json", "url", "--jq", ".url"],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    return output || null;
+  } catch {
+    return null;
+  }
+}
+function squashMergePullRequest(cwd, branch) {
+  const repo = getOriginRepoSlug(cwd);
+  const baseArgs = ["pr", "merge", branch, "--squash", "--delete-branch"];
+  if (repo) baseArgs.push("--repo", repo);
+  for (let attempt = 1; attempt <= MERGE_MAX_RETRIES; attempt++) {
+    try {
+      execFileSync("gh", baseArgs, { cwd, encoding: "utf-8" });
+      return { success: true, message: `Squash-merged PR for '${branch}' and deleted branch.` };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("not mergeable") && attempt < MERGE_MAX_RETRIES) {
+        sleepSync(MERGE_RETRY_DELAY_MS);
+        continue;
+      }
+      return { success: false, message: `PR squash-merge failed: ${msg}` };
+    }
+  }
+  return { success: false, message: "PR squash-merge failed: max retries exceeded" };
+}
+function listGroupedCycleBranches(cwd, cycleNum, baseBranch) {
+  const prefix = `feat/cycle-${cycleNum}-`;
+  let remoteBranches = [];
+  try {
+    const remoteOutput = execFileSync(
+      "git",
+      ["ls-remote", "--heads", "origin", `${prefix}*`],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    if (remoteOutput) {
+      const candidates = remoteOutput.split("\n").map((line) => line.split("	")[1]?.replace("refs/heads/", "").trim()).filter((b) => !!b && b.startsWith(prefix));
+      remoteBranches = candidates.filter((branch) => {
+        try {
+          const branchTip = execFileSync(
+            "git",
+            ["rev-parse", `origin/${branch}`],
+            { cwd, encoding: "utf-8" }
+          ).trim();
+          execFileSync(
+            "git",
+            ["merge-base", "--is-ancestor", branchTip, baseBranch],
+            { cwd, stdio: "ignore" }
+          );
+          return false;
+        } catch {
+          return true;
+        }
+      });
+    }
+  } catch {
+  }
+  const localUnmerged = getUnmergedBranches(cwd, baseBranch).filter((b) => b.startsWith(prefix));
+  const seen = new Set(remoteBranches);
+  for (const b of localUnmerged) {
+    seen.add(b);
+  }
+  return [...seen];
+}
+function isBranchMergedInto(cwd, branch, baseBranch) {
+  try {
+    const tip = execFileSync("git", ["rev-parse", branch], { cwd, encoding: "utf-8" }).trim();
+    execFileSync("git", ["merge-base", "--is-ancestor", tip, baseBranch], { cwd, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pickModuleCycleBranch(candidates, cycleNumber, module) {
+  if (candidates.length === 0) return void 0;
+  const expected = cycleBranchName(cycleNumber, module);
+  return candidates.find((b) => b === expected);
+}
+function listOrphanFeatBranches(cwd, baseBranch) {
+  let remoteBranches = [];
+  try {
+    const remoteOutput = execFileSync(
+      "git",
+      ["ls-remote", "--heads", "origin", "feat/*"],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    if (remoteOutput) {
+      const candidates = remoteOutput.split("\n").map((line) => line.split("	")[1]?.replace("refs/heads/", "").trim()).filter((b) => !!b && b.startsWith("feat/") && !b.startsWith("feat/cycle-"));
+      remoteBranches = candidates.filter((branch) => {
+        try {
+          const branchTip = execFileSync(
+            "git",
+            ["rev-parse", `origin/${branch}`],
+            { cwd, encoding: "utf-8" }
+          ).trim();
+          execFileSync(
+            "git",
+            ["merge-base", "--is-ancestor", branchTip, baseBranch],
+            { cwd, stdio: "ignore" }
+          );
+          return false;
+        } catch {
+          return true;
+        }
+      });
+    }
+  } catch {
+  }
+  const localUnmerged = getUnmergedBranches(cwd, baseBranch).filter(
+    (b) => b.startsWith("feat/") && !b.startsWith("feat/cycle-")
+  );
+  const seen = new Set(remoteBranches);
+  for (const b of localUnmerged) {
+    seen.add(b);
+  }
+  return [...seen];
+}
+function getFilesChangedFromBase(cwd, baseBranch) {
+  try {
+    const mergeBase = execFileSync("git", ["merge-base", baseBranch, "HEAD"], { cwd, encoding: "utf-8" }).trim();
+    const output = execFileSync("git", ["diff", "--name-only", mergeBase, "HEAD"], { cwd, encoding: "utf-8" }).trim();
+    return output ? output.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+function getFilesChangedBetween(cwd, fromRef, toRef) {
+  try {
+    const output = execFileSync(
+      "git",
+      ["diff", "--name-only", fromRef, toRef],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    return output ? output.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+function getLastCommitFiles(cwd) {
+  try {
+    const output = execFileSync(
+      "git",
+      ["diff", "--name-only", "HEAD~1", "HEAD"],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    return output ? output.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+function getRemoteBranchFiles(cwd, branch, baseBranch) {
+  try {
+    const output = execFileSync(
+      "git",
+      ["diff", "--name-only", baseBranch, `origin/${branch}`],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    return output ? output.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+var AUTO_WRITTEN_PATHS, GIT_NETWORK_TIMEOUT_MS, MERGE_RETRY_DELAY_MS, MERGE_MAX_RETRIES;
+var init_git = __esm({
+  "src/lib/git.ts"() {
+    "use strict";
+    AUTO_WRITTEN_PATHS = [".papi/*"];
+    GIT_NETWORK_TIMEOUT_MS = 6e4;
+    MERGE_RETRY_DELAY_MS = 2e3;
+    MERGE_MAX_RETRIES = 3;
+  }
+});
+
+// src/proxy-adapter.ts
+var proxy_adapter_exports = {};
+__export(proxy_adapter_exports, {
+  ProxyPapiAdapter: () => ProxyPapiAdapter
+});
+function snakeToCamel(str) {
+  return str.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function parseIfDoubleEncoded(value) {
+  if (typeof value !== "string") return value;
+  try {
+    const parsed = JSON.parse(value);
+    return typeof parsed === "object" ? parsed : value;
+  } catch {
+    return value;
+  }
+}
+function transformKeys(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (Array.isArray(obj)) return obj.map(transformKeys);
+  if (typeof obj === "object" && obj !== null) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const camelKey = snakeToCamel(key);
+      result[camelKey] = JSONB_PASSTHROUGH_KEYS.has(camelKey) ? parseIfDoubleEncoded(value) : transformKeys(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function fixDisplayIdEntity(obj) {
+  if (obj.displayId !== void 0) {
+    obj.uuid = obj.id;
+    obj.id = obj.displayId;
+  }
+  return obj;
+}
+function fixDisplayIdEntities(data) {
+  if (Array.isArray(data)) return data.map((item) => fixDisplayIdEntity(item));
+  if (data && typeof data === "object") return fixDisplayIdEntity(data);
+  return data;
+}
+var JSONB_PASSTHROUGH_KEYS, DISPLAY_ID_METHODS, ProxyPapiAdapter;
+var init_proxy_adapter = __esm({
+  "src/proxy-adapter.ts"() {
+    "use strict";
+    JSONB_PASSTHROUGH_KEYS = /* @__PURE__ */ new Set([
+      "buildHandoff",
+      "stateHistory",
+      "handoffAccuracy",
+      "briefImplications",
+      "autoReview",
+      "structuredData",
+      "data"
+    ]);
+    DISPLAY_ID_METHODS = /* @__PURE__ */ new Set([
+      "queryBoard",
+      "getTask",
+      "getTasks",
+      "createTask",
+      "getRecentBuildReports",
+      "getBuildReportsSince",
+      "getRecentReviews",
+      "getActiveDecisions"
+    ]);
+    ProxyPapiAdapter = class _ProxyPapiAdapter {
+      endpoint;
+      apiKey;
+      projectId;
+      constructor(config) {
+        this.endpoint = config.endpoint.replace(/\/$/, "");
+        this.apiKey = config.apiKey;
+        this.projectId = config.projectId ?? "";
+      }
+      /** Resolved project ID — available after ensureProject() completes. */
+      getProjectId() {
+        return this.projectId;
+      }
+      /**
+       * task-2119: per-call project scope. Returns a fresh adapter bound to a
+       * different projectId — instantiation is a cheap allocation (fetch wrapper,
+       * no pool). Never mutates the session adapter, persists nothing. Ownership
+       * must be validated by the caller (listUserProjects) before use; the
+       * data-proxy's validateProjectAccess re-checks server-side regardless.
+       */
+      withProject(projectId) {
+        return new _ProxyPapiAdapter({
+          endpoint: this.endpoint,
+          apiKey: this.apiKey,
+          projectId
+        });
+      }
+      /**
+       * Ensure the authenticated user has a project. If none exists, auto-creates one.
+       * Returns the project ID (existing or newly created). Idempotent and race-safe.
+       *
+       * Call this before any other adapter method when PAPI_PROJECT_ID is not configured.
+       */
+      async ensureProject(projectName, repoUrl, papiDir, rootCommitHash) {
+        const url = `${this.endpoint}/ensure-project`;
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify({
+            ...projectName ? { projectName } : {},
+            ...repoUrl ? { repoUrl } : {},
+            ...papiDir ? { papiDir } : {},
+            ...rootCommitHash ? { rootCommitHash, resolutionMethod: "root_hash" } : {}
+          }),
+          // 20s ceiling — auto-provision can be slower than a normal invoke
+          // (DB row create + RLS setup) but must never hang indefinitely.
+          signal: AbortSignal.timeout(2e4)
+        });
+        if (!response.ok) {
+          const errorBody = await response.text();
+          let message;
+          try {
+            const parsed = JSON.parse(errorBody);
+            message = parsed.error ?? errorBody;
+          } catch {
+            message = errorBody;
+          }
+          throw new Error(`Auto-provision failed (${response.status}): ${message}`);
+        }
+        const body = await response.json();
+        if (!body.ok && body.error) {
+          throw new Error(`Auto-provision failed: ${body.error}`);
+        }
+        this.projectId = body.projectId;
+        return { projectId: body.projectId, projectName: body.projectName, created: body.created };
+      }
+      /**
+       * Send an adapter method call to the proxy Edge Function.
+       * Serializes { projectId, method, args } and deserializes the response.
+       * Results are transformed from snake_case to camelCase to match pg adapter output.
+       */
+      async invoke(method, args = []) {
+        const url = `${this.endpoint}/invoke`;
+        let response;
+        try {
+          response = await fetch(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({
+              projectId: this.projectId,
+              method,
+              args
+            }),
+            // Ceiling on every proxy call. Without this, a single hung edge-function
+            // request would stall orient (15+ proxy calls) indefinitely. See PERF
+            // investigation 2026-05-04 — this was the "orient loading forever"
+            // class of incident for external users.
+            signal: AbortSignal.timeout(15e3)
+          });
+        } catch (err) {
+          if (err instanceof Error && err.name === "TimeoutError") {
+            throw new Error(`Proxy timeout on ${method}: no response within 15s. The data-proxy edge function may be cold or overloaded \u2014 retry, or check Supabase status.`);
+          }
+          throw err;
+        }
+        if (!response.ok) {
+          const errorBody = await response.text();
+          let message;
+          try {
+            const parsed = JSON.parse(errorBody);
+            message = parsed.error ?? errorBody;
+          } catch {
+            message = errorBody;
+          }
+          if (response.status === 401) {
+            throw new Error(
+              `Auth: Invalid API key \u2014 PAPI_DATA_API_KEY was rejected by the proxy.
+Check PAPI_DATA_API_KEY in your .mcp.json config. You can regenerate it from the PAPI dashboard.
+(${response.status} on ${method}: ${message})`
+            );
+          }
+          if (response.status === 403 || response.status === 404) {
+            throw new Error(
+              `Auth: Project not found or access denied \u2014 PAPI_PROJECT_ID may be wrong.
+Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI dashboard settings.
+(${response.status} on ${method}: ${message})`
+            );
+          }
+          throw new Error(`Proxy error (${response.status}) on ${method}: ${message}`);
+        }
+        const body = await response.json();
+        if (!body.ok && body.error) {
+          const codeTag = body.code ? ` [${body.code}]` : "";
+          throw new Error(`Proxy error on ${method}${codeTag}: ${body.error}`);
+        }
+        let result = transformKeys(body.result);
+        if (DISPLAY_ID_METHODS.has(method)) {
+          result = fixDisplayIdEntities(result);
+        }
+        return result;
+      }
+      /** Check if the proxy is reachable. */
+      async probeConnection() {
+        try {
+          const response = await fetch(`${this.endpoint}/health`, {
+            signal: AbortSignal.timeout(5e3)
+          });
+          return response.ok;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Fetch the proxy's reported version (task-1622 handshake).
+       * Returns undefined if the proxy is unreachable or its response is malformed —
+       * callers must treat undefined as "no signal", not as a mismatch.
+       */
+      async getProxyVersion() {
+        try {
+          const response = await fetch(`${this.endpoint}/health`, {
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!response.ok) return void 0;
+          const body = await response.json();
+          return typeof body.version === "string" ? body.version : void 0;
+        } catch {
+          return void 0;
+        }
+      }
+      /**
+       * Validate API key and project access against the proxy.
+       * Returns HTTP status so callers can distinguish 401 (bad key) from 403/404 (bad project).
+       * Status 0 means a network error occurred.
+       */
+      async probeAuth(projectId) {
+        try {
+          const response = await fetch(`${this.endpoint}/invoke`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({ projectId, method: "projectExists", args: [] }),
+            signal: AbortSignal.timeout(5e3)
+          });
+          return { ok: response.ok, status: response.status };
+        } catch {
+          return { ok: false, status: 0 };
+        }
+      }
+      // --- Planning & Health ---
+      readPlanningLog() {
+        return this.invoke("readPlanningLog");
+      }
+      getCycleHealth() {
+        return this.invoke("getCycleHealth");
+      }
+      getActiveDecisions(options) {
+        return this.invoke("getActiveDecisions", [options ?? {}]);
+      }
+      getCycleLog(limit) {
+        return this.invoke("getCycleLog", [limit]);
+      }
+      getCycleLogSince(cycleNumber) {
+        return this.invoke("getCycleLogSince", [cycleNumber]);
+      }
+      setCycleHealth(updates) {
+        return this.invoke("setCycleHealth", [updates]);
+      }
+      writeCycleLogEntry(entry) {
+        return this.invoke("writeCycleLogEntry", [entry]);
+      }
+      updateActiveDecision(id, body, cycleNumber) {
+        return this.invoke("updateActiveDecision", [id, body, cycleNumber]);
+      }
+      upsertActiveDecision(id, body, title, confidence, cycleNumber) {
+        return this.invoke("upsertActiveDecision", [id, body, title, confidence, cycleNumber]);
+      }
+      deleteActiveDecision(id) {
+        return this.invoke("deleteActiveDecision", [id]);
+      }
+      // --- Board / Tasks ---
+      queryBoard(options) {
+        return this.invoke("queryBoard", [options]);
+      }
+      getTask(id) {
+        return this.invoke("getTask", [id]);
+      }
+      getTasks(ids) {
+        return this.invoke("getTasks", [ids]);
+      }
+      createTask(task) {
+        return this.invoke("createTask", [task]);
+      }
+      updateTask(id, updates, options) {
+        return this.invoke("updateTask", [id, updates, options]);
+      }
+      updateTaskStatus(id, status) {
+        return this.invoke("updateTaskStatus", [id, status]);
+      }
+      // task-2155 (MU-3 task B): hosted/proxy claim write-path. The data-proxy gates
+      // these via WRITE_METHODS (active editor may write, viewer cannot) and binds the
+      // assignee to the bearer-derived caller server-side — the assigneeId passed here
+      // is ignored by the edge function, so it cannot be spoofed to claim on another's
+      // behalf. Mirrors pg-papi-adapter.claimTask/unclaimTask (proxy-parity enforced).
+      claimTask(taskId, assigneeId) {
+        return this.invoke("claimTask", [taskId, assigneeId]);
+      }
+      unclaimTask(taskId, assigneeId) {
+        return this.invoke("unclaimTask", [taskId, assigneeId]);
+      }
+      recordTransition(taskId, fromStatus, toStatus, changedBy) {
+        return this.invoke("recordTransition", [taskId, fromStatus, toStatus, changedBy]);
+      }
+      // --- Build Reports ---
+      appendBuildReport(report) {
+        return this.invoke("appendBuildReport", [report]);
+      }
+      getRecentBuildReports(count) {
+        return this.invoke("getRecentBuildReports", [count]);
+      }
+      getBuildReportsSince(cycleNumber) {
+        return this.invoke("getBuildReportsSince", [cycleNumber]);
+      }
+      // --- Reviews ---
+      getRecentReviews(count) {
+        return this.invoke("getRecentReviews", [count]);
+      }
+      writeReview(review) {
+        return this.invoke("writeReview", [review]);
+      }
+      // --- Compression / Archive ---
+      compressCycleLog(threshold, summary) {
+        return this.invoke("compressCycleLog", [threshold, summary]);
+      }
+      compressBuildReports(threshold, summary) {
+        return this.invoke("compressBuildReports", [threshold, summary]);
+      }
+      archiveTasks(phases, statuses) {
+        return this.invoke("archiveTasks", [phases, statuses]);
+      }
+      // --- Product Brief & Discovery ---
+      readProductBrief() {
+        return this.invoke("readProductBrief");
+      }
+      updateProductBrief(content) {
+        return this.invoke("updateProductBrief", [content]);
+      }
+      readDiscoveryCanvas() {
+        return this.invoke("readDiscoveryCanvas");
+      }
+      updateDiscoveryCanvas(canvas) {
+        return this.invoke("updateDiscoveryCanvas", [canvas]);
+      }
+      // --- Phases & Hierarchy ---
+      readPhases() {
+        return this.invoke("readPhases");
+      }
+      writePhases(phases) {
+        return this.invoke("writePhases", [phases]);
+      }
+      readHorizons() {
+        return this.invoke("readHorizons");
+      }
+      readStages(horizonId) {
+        return this.invoke("readStages", [horizonId]);
+      }
+      updateStageStatus(stageId, status) {
+        return this.invoke("updateStageStatus", [stageId, status]);
+      }
+      updateHorizonStatus(horizonId, status) {
+        return this.invoke("updateHorizonStatus", [horizonId, status]);
+      }
+      getActiveStage() {
+        return this.invoke("getActiveStage");
+      }
+      createHorizon(horizon) {
+        return this.invoke("createHorizon", [horizon]);
+      }
+      createStage(stage) {
+        return this.invoke("createStage", [stage]);
+      }
+      linkPhasesToStage(stageId) {
+        return this.invoke("linkPhasesToStage", [stageId]);
+      }
+      // --- Metrics ---
+      appendToolMetric(metric) {
+        return this.invoke("appendToolMetric", [metric]);
+      }
+      readToolMetrics() {
+        return this.invoke("readToolMetrics");
+      }
+      hasToolMilestone(name) {
+        return this.invoke("hasToolMilestone", [name]);
+      }
+      insertPlanRun(entry) {
+        return this.invoke("insertPlanRun", [entry]);
+      }
+      getCostSummary(cycleNumber) {
+        return this.invoke("getCostSummary", [cycleNumber]);
+      }
+      getCostSnapshots() {
+        return this.invoke("getCostSnapshots");
+      }
+      appendCycleMetrics(snapshot) {
+        return this.invoke("appendCycleMetrics", [snapshot]);
+      }
+      readCycleMetrics() {
+        return this.invoke("readCycleMetrics");
+      }
+      // --- Cycles ---
+      readCycles() {
+        return this.invoke("readCycles");
+      }
+      createCycle(cycle) {
+        return this.invoke("createCycle", [cycle]);
+      }
+      getContextHashes(cycleNumber) {
+        return this.invoke("getContextHashes", [cycleNumber]);
+      }
+      // --- Registries ---
+      readRegistries() {
+        return this.invoke("readRegistries");
+      }
+      updateRegistries(registries) {
+        return this.invoke("updateRegistries", [registries]);
+      }
+      // --- Recommendations ---
+      writeRecommendation(rec) {
+        return this.invoke("writeRecommendation", [rec]);
+      }
+      getPendingRecommendations() {
+        return this.invoke("getPendingRecommendations");
+      }
+      actionRecommendation(id, cycleNumber) {
+        return this.invoke("actionRecommendation", [id, cycleNumber]);
+      }
+      dismissRecommendation(id, reason) {
+        return this.invoke("dismissRecommendation", [id, reason]);
+      }
+      // --- Decision Events & Scores ---
+      appendDecisionEvent(event) {
+        return this.invoke("appendDecisionEvent", [event]);
+      }
+      getDecisionEvents(decisionId, limit) {
+        return this.invoke("getDecisionEvents", [decisionId, limit]);
+      }
+      getDecisionEventsSince(cycle) {
+        return this.invoke("getDecisionEventsSince", [cycle]);
+      }
+      writeDecisionScore(score) {
+        return this.invoke("writeDecisionScore", [score]);
+      }
+      getDecisionScores(decisionId) {
+        return this.invoke("getDecisionScores", [decisionId]);
+      }
+      getLatestDecisionScores() {
+        return this.invoke("getLatestDecisionScores");
+      }
+      logEntityReferences(refs) {
+        return this.invoke("logEntityReferences", [refs]);
+      }
+      getDecisionUsage(currentCycle) {
+        return this.invoke("getDecisionUsage", [currentCycle]);
+      }
+      getContextUtilisation() {
+        return this.invoke("getContextUtilisation");
+      }
+      // --- Strategy Reviews ---
+      writeStrategyReview(review) {
+        return this.invoke("writeStrategyReview", [review]);
+      }
+      getLastStrategyReviewCycle() {
+        return this.invoke("getLastStrategyReviewCycle");
+      }
+      getStrategyReviews(limit, includeFullAnalysis) {
+        return this.invoke("getStrategyReviews", [limit, includeFullAnalysis]);
+      }
+      // --- Dogfood ---
+      writeDogfoodEntries(entries) {
+        return this.invoke("writeDogfoodEntries", [entries]);
+      }
+      getDogfoodLog(limit) {
+        return this.invoke("getDogfoodLog", [limit]);
+      }
+      getUnactionedDogfoodEntries(limit) {
+        return this.invoke("getUnactionedDogfoodEntries", [limit]);
+      }
+      updateDogfoodEntryStatus(id, status, linkedTaskId) {
+        return this.invoke("updateDogfoodEntryStatus", [id, status, linkedTaskId]);
+      }
+      // --- Harness inventory (task-1896) ---
+      getHarnessInventory() {
+        return this.invoke("getHarnessInventory");
+      }
+      replaceHarnessInventory(entries) {
+        return this.invoke("replaceHarnessInventory", [entries]);
+      }
+      getHarnessState() {
+        return this.invoke("getHarnessState");
+      }
+      setHarnessState(fingerprint) {
+        return this.invoke("setHarnessState", [fingerprint]);
+      }
+      // --- North Star ---
+      getCurrentNorthStar() {
+        return this.invoke("getCurrentNorthStar");
+      }
+      getNorthStarSetCycle() {
+        return this.invoke("getNorthStarSetCycle");
+      }
+      getNorthStarStaleness() {
+        return this.invoke("getNorthStarStaleness");
+      }
+      upsertNorthStar(statement, cycleNumber) {
+        return this.invoke("upsertNorthStar", [statement, cycleNumber]);
+      }
+      // --- Optional pg-only methods ---
+      getEstimationCalibration() {
+        return this.invoke("getEstimationCalibration");
+      }
+      getRecentTaskComments(limit) {
+        return this.invoke("getRecentTaskComments", [limit]);
+      }
+      getRecommendationEffectiveness() {
+        return this.invoke("getRecommendationEffectiveness");
+      }
+      getPlanContextSummary() {
+        return this.invoke("getPlanContextSummary");
+      }
+      projectExists() {
+        return this.invoke("projectExists");
+      }
+      getBuildReportCountForTask(taskId) {
+        return this.invoke("getBuildReportCountForTask", [taskId]);
+      }
+      // --- Bug Reports ---
+      submitBugReport(report) {
+        return this.invoke("submitBugReport", [report]);
+      }
+      // --- Doc Registry ---
+      registerDoc(entry) {
+        return this.invoke("registerDoc", [entry]);
+      }
+      searchDocs(input) {
+        return this.invoke("searchDocs", [input]);
+      }
+      getDoc(idOrPath) {
+        return this.invoke("getDoc", [idOrPath]);
+      }
+      updateDocStatus(id, status, supersededBy) {
+        return this.invoke("updateDocStatus", [id, status, supersededBy]);
+      }
+      // --- Cycle Learnings ---
+      appendCycleLearnings(learnings) {
+        return this.invoke("appendCycleLearnings", [learnings]);
+      }
+      getCycleLearnings(opts) {
+        return this.invoke("getCycleLearnings", [opts]);
+      }
+      getCycleLearningPatterns() {
+        return this.invoke("getCycleLearningPatterns", []);
+      }
+      updateCycleLearningActionRef(learningId, taskDisplayId) {
+        return this.invoke("updateCycleLearningActionRef", [learningId, taskDisplayId]);
+      }
+      // --- Strategy Review Drafts ---
+      savePendingReviewResponse(cycleNumber, rawResponse) {
+        return this.invoke("savePendingReviewResponse", [cycleNumber, rawResponse]);
+      }
+      getPendingReviewResponse() {
+        return this.invoke("getPendingReviewResponse", []);
+      }
+      clearPendingReviewResponse() {
+        return this.invoke("clearPendingReviewResponse", []);
+      }
+      // --- Active Decisions ---
+      confirmPendingActiveDecisions(cycleNumber) {
+        return this.invoke("confirmPendingActiveDecisions", [cycleNumber]);
+      }
+      // --- Owner Action Queue counters (Team Ops) ---
+      // Proxy-mode users get the orient owner-action nudges too. SECURITY: the
+      // data-proxy ignores the client-supplied userId and scopes every count to
+      // the AUTHENTICATED bearer's user_id server-side — the arg is advisory.
+      getProjectOwnerUserId() {
+        return this.invoke("getProjectOwnerUserId", []);
+      }
+      countOpenOwnerActions(userId, projectId) {
+        return this.invoke("countOpenOwnerActions", [userId, projectId]);
+      }
+      countNudgedOwnerActions(userId, projectId) {
+        return this.invoke("countNudgedOwnerActions", [userId, projectId]);
+      }
+      countOwnerActionsBlockingTasks(userId) {
+        return this.invoke("countOwnerActionsBlockingTasks", [userId]);
+      }
+      countDueOwnerActions(userId, projectId) {
+        return this.invoke("countDueOwnerActions", [userId, projectId]);
+      }
+      // --- Project metadata (path-identity guardrail) ---
+      async getProjectInfo() {
+        return this.invoke("getProjectInfo", []);
+      }
+      /**
+       * task-2052 (C288): owner-gate identity for the proxy transport. Both sides
+       * come from the edge function — callerUserId is derived server-side from the
+       * bearer token (never client-claimed), ownerUserId from the project row. This
+       * is what lets release/review enforce the owner-gate on the proxy (previously
+       * bypassed) without locking out a legitimate owner who has no PAPI_USER_ID set.
+       */
+      async getOwnerIdentity() {
+        return this.invoke("getOwnerIdentity", []);
+      }
+      // --- Contributor cohort (task-2029, C288) ---
+      // Owner-only enforcement is BOTH tool-layer (resolveOwnerGate) and
+      // server-side in the edge function (auth-derived caller vs project owner) —
+      // defence in depth, since this client runs on the user's machine.
+      async listContributors() {
+        return this.invoke("listContributors", []);
+      }
+      async addContributorByEmail(email) {
+        return this.invoke("addContributorByEmail", [email]);
+      }
+      async removeContributorByEmail(email) {
+        return this.invoke("removeContributorByEmail", [email]);
+      }
+      async setProjectPapiDir(papiDir) {
+        return this.invoke("setProjectPapiDir", [papiDir]);
+      }
+      // --- Project lifecycle (task-1888 / 1885-C) ---
+      // These are USER-scoped (not project-scoped), so they hit dedicated auth-only
+      // routes rather than the projectId-gated /invoke path — same pattern as
+      // ensureProject. The bearer identifies the user server-side; the body never
+      // carries a user id.
+      /** POST helper for the auth-only lifecycle routes. */
+      async postRoute(route, payload) {
+        const response = await fetch(`${this.endpoint}/${route}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(payload),
+          signal: AbortSignal.timeout(15e3)
+        });
+        if (!response.ok) {
+          const errorBody = await response.text();
+          let message;
+          try {
+            message = JSON.parse(errorBody).error ?? errorBody;
+          } catch {
+            message = errorBody;
+          }
+          throw new Error(`Proxy error (${response.status}) on ${route}: ${message}`);
+        }
+        const body = await response.json();
+        if (!body.ok && body.error) throw new Error(`Proxy error on ${route}: ${body.error}`);
+        return body;
+      }
+      /**
+       * task-2061: the authenticated user's tier + metered tool-call count for
+       * the current month. Identity is server-derived from the bearer at the
+       * data-proxy; nothing client-supplied. Consumed by services/metering.ts.
+       */
+      async getMeteredUsage() {
+        const body = await this.postRoute("metering", {});
+        return { tier: body.tier ?? "free", monthlyToolCalls: body.monthlyToolCalls ?? 0 };
+      }
+      async listUserProjects() {
+        const body = await this.postRoute("project-list", {});
+        return body.projects ?? [];
+      }
+      async createUserProject(input) {
+        const r = await this.ensureProject(input.name, input.repoUrl, input.papiDir);
+        return {
+          projectId: r.projectId,
+          name: r.projectName,
+          slug: r.slug ?? "",
+          papiDir: r.papiDir ?? input.papiDir ?? null,
+          created: r.created
+        };
+      }
+      async switchUserProject(identifier, papiDir) {
+        const body = await this.postRoute(
+          "project-switch",
+          { identifier, ...papiDir ? { papiDir } : {} }
+        );
+        this.projectId = body.projectId;
+        return { projectId: body.projectId, name: body.name, slug: body.slug, papiDir: body.papiDir ?? null, created: false };
+      }
+      // --- Atomic plan write-back ---
+      async planWriteBack(payload) {
+        const raw = await this.invoke("planWriteBack", [payload]);
+        const map = new Map(Object.entries(raw.newTaskIdMap ?? {}));
+        return { ...raw, newTaskIdMap: map };
+      }
+    };
+  }
+});
+
+// src/cli/backfill-cycle-metrics.ts
+import { pathToFileURL } from "url";
+
+// src/adapter-factory.ts
+import path2 from "path";
+import { execSync } from "child_process";
+
+// ../adapter-md/dist/index.js
+import { readFile, writeFile, access } from "fs/promises";
+import { randomUUID as randomUUID6 } from "crypto";
+import { join } from "path";
+
+// ../shared/dist/index.js
+var VALID_TRANSITIONS = {
+  "Backlog": ["In Cycle", "Ready", "In Progress", "Blocked", "Cancelled", "Deferred", "Done"],
+  "In Cycle": ["In Progress", "Backlog", "Blocked", "Cancelled"],
+  "Ready": ["In Progress", "Backlog", "Blocked", "Cancelled"],
+  "In Progress": ["In Review", "Backlog", "Blocked", "Cancelled"],
+  "In Review": ["Done", "In Progress", "Blocked", "Cancelled"],
+  "Done": [],
+  "Blocked": ["Backlog", "Ready", "In Cycle", "In Progress", "Cancelled"],
+  "Cancelled": [],
+  "Deferred": ["Backlog", "Cancelled"]
+};
+var RETIRED_DECISION_OUTCOMES = ["resolved", "abandoned", "superseded"];
+function isLiveDecision(d) {
+  if (d.superseded === true) return false;
+  if (d.outcome != null && RETIRED_DECISION_OUTCOMES.includes(d.outcome)) return false;
+  return true;
+}
+
+// ../adapter-md/dist/index.js
+import { randomUUID } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
+import yaml from "js-yaml";
+import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
+import yaml2 from "js-yaml";
+import yaml3 from "js-yaml";
+var VALID_TRANSITIONS2 = VALID_TRANSITIONS;
+var isLiveDecision2 = isLiveDecision;
+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 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*\|$/);
+    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 {
+    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 serializeCycleHealth(health, content) {
+  const section = extractSectionCompat(content, "Cycle Health", "Sprint Health") || extractSection(content, "Session Health");
+  const fieldMap = {
+    "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 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 })) {
+    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 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,
+      id: headingMatch[1],
+      displayId: headingMatch[1],
+      title: headingMatch[2].trim(),
+      confidence: headingMatch[3] ?? "HIGH",
+      superseded: !!headingMatch[4],
+      supersededBy: headingMatch[4],
+      createdCycle,
+      modifiedCycle,
+      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(createdCycle, modifiedCycle, uuid) {
+  const parts = [];
+  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 extractCreatedCycle(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, 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 ? extractCreatedCycle(existingMatch[0]) : void 0;
+    const existingUuid = existingMatch ? extractUuid(existingMatch[0]) : void 0;
+    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 = 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) {
+    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 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(/^### (?: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(/\*\*Cycle Notes:\*\*\s*([\s\S]*?)$/);
+    const notes = notesMatch ? notesMatch[1].trim() : void 0;
+    return {
+      uuid: uuid ?? randomUUID(),
+      cycleNumber,
+      title,
+      content: block,
+      carryForward: carryForwardMatch ? carryForwardMatch[1].trim() : void 0,
+      notes
+    };
+  });
+  return limit ? entries.slice(0, limit) : entries;
+}
+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("Cycle 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}
+
+**Cycle 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 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 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(/^### (?:Cycle|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 = `### Cycles 1\u2013${threshold - 1} \u2014 Compressed Summary
+
+${summary}`;
+  const newEntries = [...keep, summaryBlock].join("\n\n");
+  const newSection = `## Cycle Log
+
+${newEntries}
+`;
+  return content.replace(section, newSection);
+}
+function parsePlanningLog(content, activeDecisionsContent, cycleLogContent) {
+  return {
+    cycleHealth: parseCycleHealth(content),
+    northStar: parseNorthStar(content),
+    activeDecisions: parseActiveDecisions(activeDecisionsContent ?? content),
+    deferred: parseDeferred(content),
+    cycleLog: cycleLogContent ? parseCycleLog(cycleLogContent) : []
+  };
+}
+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",
+  "PRE-BUILD VERIFICATION",
+  "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 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);
+}
+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 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 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];
+  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,
+    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 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(`Cycle: ${handoff.cycle}`);
+  lines.push(`Why now: ${handoff.whyNow}`);
+  lines.push("");
+  lines.push("SCOPE (DO THIS)");
+  for (const item of ensureArray(handoff.scope)) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+  lines.push("SCOPE BOUNDARY (DO NOT DO THIS)");
+  for (const item of ensureArray(handoff.scopeBoundary)) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+  lines.push("ACCEPTANCE CRITERIA");
+  for (const item of ensureArray(handoff.acceptanceCriteria)) {
+    lines.push(`[ ] ${item}`);
+  }
+  lines.push("");
+  lines.push("SECURITY CONSIDERATIONS");
+  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 ensureArray(handoff.filesLikelyTouched)) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+  lines.push("EFFORT");
+  lines.push(handoff.effort ?? "M");
+  return lines.join("\n");
+}
+var YAML_MARKER = "<!-- PAPI-ADAPTER: parse the yaml block below -->";
+var YAML_START = "<!-- PAPI-YAML-START -->";
+var YAML_END = "<!-- PAPI-YAML-END -->";
+function toCycleTask(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,
+    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,
+    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,
+    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 fromCycleTask(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.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) {
+    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);
+  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) {
+  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 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 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 CYCLE_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 CYCLE_BOARD.md${lineInfo}. Check for syntax errors \u2014 unquoted special characters, bad indentation, or missing colons.${hint}`
+    );
+  }
+  return (data.tasks ?? []).map(toCycleTask);
+}
+function serializeBoard(tasks, content) {
+  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 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 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 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);
+}
+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;
+    if (options.assigneeId && task.assigneeId !== options.assigneeId) 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")}`;
+}
+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(/^(?=### .+ — .+ — (?: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(/^### (.+?) — (.+?) — (?:Cycle|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(),
+      cycle: 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 Cycle ${report.cycle}`
+  ];
+  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, 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 = [`### ${cycleRange} \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(/^(?=### .+ — .+ — (?: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(/— (?:Cycle|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 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");
+  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,
+    cycle: incoming.cycle,
+    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 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");
+  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);
+}
+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 | 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
+
+${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 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;
+    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 } : {},
+      ...cycleNumber !== void 0 ? { cycleNumber } : {},
+      ...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 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} | ${cycle} | ${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, cycleNumber) {
+  const filtered = cycleNumber !== void 0 ? metrics.filter((m) => m.cycleNumber === cycleNumber) : 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_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({
+      cycle: 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;
+}
+var FILE_HEADING = "# Cycle Methodology Metrics";
+var ACCURACY_HEADER = "| Cycle | Reports | Match Rate | MAE | Bias |";
+var ACCURACY_SEPARATOR = "|--------|---------|------------|-----|------|";
+var VELOCITY_HEADER = "| Cycle | Completed | Partial | Failed | Effort Points |";
+var VELOCITY_SEPARATOR = "|--------|-----------|---------|--------|---------------|";
+function serializeAccuracyRow(a) {
+  return `| ${a.cycle} | ${a.reports} | ${a.matchRate}% | ${a.mae} | ${a.bias >= 0 ? "+" : ""}${a.bias} |`;
+}
+function serializeVelocityRow(v) {
+  return `| ${v.cycle} | ${v.completed} | ${v.partial} | ${v.failed} | ${v.effortPoints} |`;
+}
+function serializeSnapshot(snapshot) {
+  const lines = [];
+  lines.push(`## Cycle ${snapshot.cycle} Snapshot \u2014 ${snapshot.date}`);
+  lines.push("");
+  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("### Cycle 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 = `## 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) {
+    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");
+  }
+  return content.trimEnd() + "\n\n" + block + "\n";
+}
+function parseSnapshots(content) {
+  if (!content.trim()) return [];
+  const snapshots = [];
+  const headerRegex = /^## (?:Cycle|Sprint) (\d+) Snapshot — (\S+)/gm;
+  let match;
+  const headers = [];
+  while ((match = headerRegex.exec(content)) !== null) {
+    headers.push({
+      cycle: 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({
+      cycle: headers[i].cycle,
+      date: headers[i].date,
+      accuracy,
+      velocity
+    });
+  }
+  return snapshots;
+}
+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({
+      cycle: 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({
+      cycle: 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;
+}
+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 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, cycle, 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}`,
+    `- **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) {
+  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);
+}
+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");
+}
+var YAML_MARKER2 = "<!-- PAPI-ADAPTER: parse the yaml block below -->";
+var YAML_START2 = "<!-- PAPI-YAML-START -->";
+var YAML_END2 = "<!-- PAPI-YAML-END -->";
+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,
+    startDate: raw.start_date,
+    goals: raw.goals ?? [],
+    boardHealth: raw.board_health ?? "",
+    taskIds: raw.task_ids ?? []
+  };
+  if (raw.end_date) cycle.endDate = raw.end_date;
+  if (raw.user_id) cycle.userId = raw.user_id;
+  return cycle;
+}
+function fromCycle(cycle) {
+  const raw = {
+    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 (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 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 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 CYCLES.md");
+  return afterMarker.slice(yamlStart, endIdx);
+}
+function parseCycles(content) {
+  if (!content.trim()) return [];
+  const yamlText = extractYamlBlock2(content);
+  const data = yaml2.load(yamlText);
+  return (data.cycles ?? []).map(toCycle).filter((s) => s !== null);
+}
+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 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 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 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 prependCycle(cycle, content) {
+  if (!content.trim()) {
+    const header = `# Cycles
+
+<!-- PAPI-ADAPTER: parse the yaml block below -->
+
+`;
+    const raw = fromCycle(cycle);
+    const yamlStr = yaml2.dump({ cycles: [raw] }, { lineWidth: 120, quotingType: '"' });
+    return header + YAML_START2 + "\n" + yamlStr + YAML_END2 + "\n";
+  }
+  const existing = parseCycles(content);
+  const merged = [cycle, ...existing];
+  return serializeCycles(merged, content);
+}
+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);
+}
+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 + CYCLE_LOG.md). */
+  async readPlanningLog() {
+    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, cycleLogContent);
+  }
+  /** Read the Cycle Health table from PLANNING_LOG.md. */
+  async getCycleHealth() {
+    return parseCycleHealth(await this.read("PLANNING_LOG.md"));
+  }
+  /**
+   * 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 [];
+    const all = parseActiveDecisions(content);
+    if (options?.includeRetired) return all;
+    return all.filter(isLiveDecision2);
+  }
+  /** 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 getCycleLogSince(cycleNumber) {
+    const log = await this.getCycleLog();
+    return log.filter((entry) => entry.cycleNumber >= cycleNumber);
+  }
+  /** Merge partial updates into the Cycle Health table and write back. */
+  async setCycleHealth(updates) {
+    const content = await this.read("PLANNING_LOG.md");
+    const current = parseCycleHealth(content);
+    const updated = { ...current, ...updates };
+    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", prependCycleLogEntry(patched, content));
+  }
+  /** Write a strategy review — for md adapter, delegates to cycle log. */
+  async writeStrategyReview(review) {
+    await this.writeCycleLogEntry({
+      uuid: randomUUID6(),
+      cycleNumber: review.cycleNumber,
+      title: review.title,
+      content: review.content,
+      notes: review.notes
+    });
+  }
+  /** 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?.cycleNumber ?? 0;
+  }
+  /** 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. */
+  // 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, cycleNumber));
+  }
+  // --- 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;
+  }
+  /** 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);
+    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);
+      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_TRANSITIONS2[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 });
+  }
+  /**
+   * 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) {
+    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 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.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}. */
+  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 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", compressCycleLogInContent(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_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 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_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);
+    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);
+  }
+  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");
+    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}
+`);
+    }
+  }
+  // --- 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);
+  }
+  async hasToolMilestone(name) {
+    const metrics = await this.readToolMetrics();
+    return metrics.some((m) => m.tool === name);
+  }
+  /** 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() {
+    const content = await this.readOptional("METRICS.md");
+    if (!content) return [];
+    return parseCostSnapshots(content);
+  }
+  // --- 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 cycle metrics snapshots from CYCLE_METRICS.md. */
+  async readCycleMetrics() {
+    const content = await this.readOptional("SPRINT_METRICS.md");
+    if (!content) return [];
+    return parseSnapshots(content);
+  }
+  // --- Cycles ---
+  /** Read all Cycle entities from CYCLES.md (newest first). */
+  async readCycles() {
+    const content = await this.readOptional("CYCLES.md");
+    if (!content) return [];
+    return parseCycles(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. */
+  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.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}
+${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_cycle:\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,
+        createdCycle: parseInt(createdMatch[1], 10),
+        actionedCycle: actionedMatch ? parseInt(actionedMatch[1], 10) : void 0
+      });
+    }
+    return recs;
+  }
+  /** Mark a recommendation as actioned. */
+  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_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) {
+    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} | 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}
+
+---
+
+`;
+    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(cycle) {
+    const all = await this.parseDecisionEvents();
+    return all.filter((e) => e.cycle >= cycle);
+  }
+  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+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],
+        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()
+      });
+    }
+    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} | Cycle ${full.cycle}
+- **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.cycle > existing.cycle) {
+        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+Cycle\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],
+        cycle: 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(_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/lib/path-identity.ts
+import fs from "fs";
+import path from "path";
+function realpathOrSelf(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function checkProjectPathIdentity(opts) {
+  const { storedPapiDir, projectName, cwd } = opts;
+  const log = opts.log ?? ((msg) => console.error(msg));
+  const allowMigrate = opts.allowMigrate ?? (process.env.PAPI_ALLOW_PATH_MIGRATE === "1" || process.env.PAPI_ALLOW_PATH_MIGRATE === "true");
+  const realCwd = realpathOrSelf(cwd);
+  const expectedPapiDir = path.join(realCwd, ".papi");
+  if (!storedPapiDir || storedPapiDir.trim() === "" || storedPapiDir.trim() === ".") {
+    log(`[papi] Backfilling project root for '${projectName}' from current cwd: ${realCwd}`);
+    return { action: "backfill", newPapiDir: expectedPapiDir };
+  }
+  const trimmed = storedPapiDir.trim();
+  const endsInPapi = trimmed.endsWith("/.papi") || trimmed.endsWith("\\.papi");
+  const isWindowsPath = /^[A-Za-z]:[\\/]/.test(trimmed);
+  const realStored = realpathOrSelf(trimmed);
+  let storedProjectRoot;
+  if (endsInPapi) {
+    storedProjectRoot = isWindowsPath ? path.win32.dirname(realStored) : path.dirname(realStored);
+  } else {
+    storedProjectRoot = realStored;
+  }
+  if (storedProjectRoot === realCwd) {
+    if (!endsInPapi) {
+      log(`[papi] Normalising legacy papi_dir for '${projectName}': ${trimmed} \u2192 ${expectedPapiDir}`);
+      return { action: "migrate", newPapiDir: expectedPapiDir };
+    }
+    return { action: "ok" };
+  }
+  if (allowMigrate) {
+    log(
+      `[papi] PAPI_ALLOW_PATH_MIGRATE set \u2014 updating project '${projectName}' root: ${storedProjectRoot} \u2192 ${realCwd}`
+    );
+    return { action: "migrate", newPapiDir: expectedPapiDir };
+  }
+  throw new Error(
+    `PAPI is configured for project '${projectName}' which was set up in ${storedProjectRoot},
+but you're running in ${realCwd}.
+
+To fix:
+  - cd to the right project directory, OR
+  - run \`setup\` to attach this directory to a project, OR
+  - update PAPI_PROJECT_ID in .mcp.json if you intentionally moved the project, OR
+  - set PAPI_ALLOW_PATH_MIGRATE=1 to update the stored path on next boot.`
+  );
+}
+
+// src/lib/project-resolution.ts
+function assertWorkspaceMatch(input) {
+  if (!input.workspacePath) return null;
+  return checkProjectPathIdentity({
+    storedPapiDir: input.storedPapiDir,
+    projectName: input.projectName,
+    cwd: input.workspacePath,
+    allowMigrate: input.allowMigrate,
+    log: input.log
+  });
+}
+
+// src/adapter-factory.ts
+function detectUserId() {
+  try {
+    const email = execSync("git config user.email", { encoding: "utf8", timeout: 5e3 }).trim();
+    if (email) return email;
+  } catch {
+  }
+  try {
+    const ghUser = execSync("gh api user --jq .email", { encoding: "utf8", timeout: 1e4 }).trim();
+    if (ghUser && ghUser !== "null") return ghUser;
+  } catch {
+  }
+  return void 0;
+}
+var HOSTED_SUPABASE_URL = process.env["PAPI_HOSTED_SUPABASE_URL"] ?? "https://guewgygcpcmrcoppihzx.supabase.co";
+var HOSTED_PROXY_ENDPOINT = `${HOSTED_SUPABASE_URL}/functions/v1/data-proxy`;
+var PLACEHOLDER_PATTERNS = [
+  "<YOUR_DATABASE_URL>",
+  "your-database-url",
+  "your_database_url",
+  "placeholder",
+  "example.com",
+  "localhost:5432/dbname",
+  "user:password@host"
+];
+function validateDatabaseUrl(connectionString) {
+  const lower = connectionString.toLowerCase().trim();
+  if (PLACEHOLDER_PATTERNS.some((p) => lower.includes(p.toLowerCase()))) {
+    throw new Error(
+      "DATABASE_URL contains a placeholder value and is not configured.\nReplace it with your actual Supabase connection string in .mcp.json.\nIf you don't have one yet, contact the PAPI admin for access."
+    );
+  }
+  if (!lower.startsWith("postgres://") && !lower.startsWith("postgresql://")) {
+    throw new Error(
+      `DATABASE_URL must be a PostgreSQL connection string (postgres:// or postgresql://).
+Got: "${connectionString.slice(0, 30)}..."
+Check your .mcp.json configuration.`
+    );
+  }
+}
+var _connectionStatus = "offline";
+var _pathIdentityChecked = false;
+async function createAdapter(optionsOrType, maybePapiDir) {
+  const options = typeof optionsOrType === "string" ? { adapterType: optionsOrType, papiDir: maybePapiDir } : optionsOrType;
+  const { adapterType, papiDir, papiEndpoint } = options;
+  switch (adapterType) {
+    case "md":
+      _connectionStatus = "offline";
+      return new MdFileAdapter(papiDir);
+    case "pg": {
+      const { PgAdapter, PgPapiAdapter, configFromEnv } = await import("@papi-ai/adapter-pg");
+      let projectId = process.env["PAPI_PROJECT_ID"];
+      const projectRoot = options.projectRoot ?? process.env["PAPI_PROJECT_DIR"] ?? process.cwd();
+      let rootHash = null;
+      let originUrl = null;
+      try {
+        const { getRootCommitHash: getRootCommitHash2, getOriginUrl: getOriginUrl2 } = await Promise.resolve().then(() => (init_git(), git_exports));
+        rootHash = getRootCommitHash2(projectRoot);
+        originUrl = getOriginUrl2(projectRoot);
+      } catch {
+      }
+      const resolveUserId = process.env["PAPI_USER_ID"] ?? detectUserId() ?? null;
+      if (!projectId) {
+        const method = options.resolutionMethod ?? "root_hash";
+        if (method === "manual") {
+          throw new Error(
+            'PAPI_PROJECT_ID is required when resolution method is "manual". Set it to the UUID of your project in .mcp.json.'
+          );
+        }
+        const config2 = papiEndpoint ? { connectionString: papiEndpoint } : configFromEnv();
+        validateDatabaseUrl(config2.connectionString);
+        const probeAdapter = new PgAdapter(config2);
+        try {
+          const { normalizeGitUrl: normalizeGitUrl2 } = await Promise.resolve().then(() => (init_git(), git_exports));
+          if (method === "root_hash") {
+            if (rootHash) {
+              const match = await probeAdapter.findProjectByRootHash(rootHash, resolveUserId);
+              if (match) {
+                projectId = match.id;
+                console.error(`[papi] \u2713 Resolved project via root commit hash: ${match.name ?? match.slug} (${match.id})`);
+              } else {
+                console.error(`[papi] \u26A0 No project matched root commit hash ${rootHash.slice(0, 8)}\u2026`);
+              }
+            } else {
+              console.error("[papi] \u26A0 Not a git repo (or shallow clone) \u2014 cannot resolve by root hash.");
+            }
+          }
+          if (method === "repo_url") {
+            const normalized = originUrl ? normalizeGitUrl2(originUrl) : null;
+            if (normalized) {
+              const match = await probeAdapter.findProjectByRepoUrl(normalized, resolveUserId);
+              if (match) {
+                projectId = match.id;
+                console.error(`[papi] \u2713 Resolved project via repo URL: ${match.name ?? match.slug} (${match.id})`);
+              } else {
+                console.error(`[papi] \u26A0 No project matched repo URL ${normalized}`);
+              }
+            } else {
+              console.error("[papi] \u26A0 No git remote found \u2014 cannot resolve by repo URL.");
+            }
+          }
+        } finally {
+          try {
+            await probeAdapter.close();
+          } catch {
+          }
+        }
+      }
+      if (!projectId) {
+        throw new Error(
+          "PAPI_PROJECT_ID is required when using PostgreSQL storage. Set it to the UUID of your project in the database, or switch resolution method to root_hash or repo_url."
+        );
+      }
+      const config = papiEndpoint ? { connectionString: papiEndpoint } : configFromEnv();
+      validateDatabaseUrl(config.connectionString);
+      const { ensureSchema } = await import("@papi-ai/adapter-pg");
+      try {
+        await ensureSchema(config);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(
+          `PAPI schema creation failed: ${msg}
+  This usually means DATABASE_URL is wrong, the database is unreachable, or the connection role lacks permission to create tables/extensions. Verify DATABASE_URL points to your Supabase pooler (port 5432, session mode) and uses the service role connection, then restart the MCP server.`
+        );
+      }
+      const pgAdapter = new PgAdapter(config);
+      try {
+        const existing = await pgAdapter.getProject(projectId);
+        if (!existing) {
+          const slug = path2.basename(projectRoot) || "unnamed";
+          let userId = process.env["PAPI_USER_ID"] ?? void 0;
+          if (!userId) {
+            userId = detectUserId();
+            if (userId) {
+              console.error(`[papi] Auto-detected user identity: ${userId}`);
+              console.error("[papi] Set PAPI_USER_ID in .mcp.json to make this explicit.");
+            } else {
+              console.error("[papi] \u26A0 No PAPI_USER_ID set and auto-detection failed.");
+              console.error("[papi]   Project will have no user scope \u2014 it may be visible to all dashboard users.");
+              console.error("[papi]   Set PAPI_USER_ID in your .mcp.json env to fix this.");
+            }
+          }
+          let skipCreate = false;
+          if (userId) {
+            const bySlug = await pgAdapter.listProjects({ slug });
+            const userDup = bySlug.find((p) => p.user_id === userId);
+            if (userDup) {
+              console.error(`[papi] \u26A0 Project '${slug}' already exists for this user (id: ${userDup.id}).`);
+              console.error(`[papi]   Update PAPI_PROJECT_ID=${userDup.id} in .mcp.json to avoid a duplicate.`);
+              skipCreate = true;
+            }
+          }
+          if (!skipCreate) {
+            await pgAdapter.createProject({
+              id: projectId,
+              slug,
+              name: slug,
+              papi_dir: papiDir,
+              user_id: userId,
+              root_commit_hash: rootHash ?? void 0,
+              repo_url: originUrl ?? void 0,
+              resolution_method: rootHash ? "root_hash" : "manual"
+            });
+          }
+        } else {
+          if (!existing.root_commit_hash && rootHash) {
+            try {
+              await pgAdapter.updateProject(projectId, {
+                root_commit_hash: rootHash,
+                repo_url: originUrl ?? void 0,
+                resolution_method: "root_hash"
+              });
+            } catch (err) {
+              console.error(
+                `[papi] \u26A0 Failed to backfill root_commit_hash: ${err instanceof Error ? err.message : String(err)}`
+              );
+            }
+          }
+          if (!_pathIdentityChecked) {
+            _pathIdentityChecked = true;
+            const cwd = options.projectRoot ?? process.env["PAPI_PROJECT_DIR"] ?? process.cwd();
+            const projectName = existing.name ?? existing.slug ?? projectId;
+            const result = assertWorkspaceMatch({
+              storedPapiDir: existing.papi_dir,
+              projectName,
+              workspacePath: cwd
+            });
+            if (result && (result.action === "backfill" || result.action === "migrate")) {
+              try {
+                await pgAdapter.updateProject(projectId, { papi_dir: result.newPapiDir });
+              } catch (err) {
+                console.error(
+                  `[papi] Failed to persist papi_dir update: ${err instanceof Error ? err.message : String(err)}`
+                );
+              }
+            }
+          }
+          if (existing.user_id) {
+            const configuredUserId = process.env["PAPI_USER_ID"] ?? detectUserId();
+            if (configuredUserId && existing.user_id !== configuredUserId) {
+              console.error(`[papi] \u26A0 PAPI_PROJECT_ID=${projectId} belongs to a different user.`);
+              console.error("[papi]   Run papi setup or update PAPI_PROJECT_ID in .mcp.json.");
+            }
+          }
+        }
+      } catch (err) {
+        if (err instanceof Error && err.message.startsWith("PAPI is configured for project")) {
+          throw err;
+        }
+      } finally {
+        try {
+          await pgAdapter.close();
+        } catch {
+        }
+      }
+      const adapter = new PgPapiAdapter(config, projectId);
+      try {
+        await adapter.initRls();
+      } catch {
+      }
+      const connected = await adapter.probeConnection();
+      if (connected) {
+        _connectionStatus = "connected";
+        console.error("[papi] \u2713 Supabase connected");
+      } else {
+        _connectionStatus = "degraded";
+        console.error("[papi] \u2717 Supabase unreachable \u2014 running in degraded mode, data may be stale");
+        console.error("[papi] Check your DATABASE_URL in .mcp.json \u2014 is the connection string correct?");
+      }
+      return adapter;
+    }
+    case "proxy": {
+      const { ProxyPapiAdapter: ProxyPapiAdapter2 } = await Promise.resolve().then(() => (init_proxy_adapter(), proxy_adapter_exports));
+      const dashboardUrl = process.env["PAPI_DASHBOARD_URL"] || "https://getpapi.ai";
+      const projectId = process.env["PAPI_PROJECT_ID"];
+      const dataApiKey = process.env["PAPI_DATA_API_KEY"];
+      if (!dataApiKey) {
+        throw new Error(
+          `PAPI needs an account to store your project data.
+
+Get started in 3 steps:
+  1. Sign up at ${dashboardUrl}/login
+  2. Complete the onboarding wizard \u2014 it generates your .mcp.json config
+  3. Download the config, place it in your project root, and restart Claude Code
+
+Already have an account? Make sure PAPI_DATA_API_KEY is set in your .mcp.json env config.`
+        );
+      }
+      const dataEndpoint = process.env["PAPI_DATA_ENDPOINT"] || HOSTED_PROXY_ENDPOINT;
+      const adapter = new ProxyPapiAdapter2({
+        endpoint: dataEndpoint,
+        apiKey: dataApiKey,
+        projectId: projectId || void 0
+      });
+      const connected = await adapter.probeConnection();
+      if (!connected) {
+        _connectionStatus = "degraded";
+        console.error("[papi] \u2717 Data proxy unreachable \u2014 running in degraded mode");
+        console.error("[papi] Check your PAPI_DATA_ENDPOINT configuration.");
+      } else if (projectId) {
+        const auth = await adapter.probeAuth(projectId);
+        if (!auth.ok) {
+          if (auth.status === 401) {
+            throw new Error(
+              "PAPI_DATA_API_KEY is invalid \u2014 authentication failed.\nCheck the key in your .mcp.json config. You can generate a new key from the PAPI dashboard."
+            );
+          } else if (auth.status === 403 || auth.status === 404) {
+            throw new Error(
+              `PAPI_PROJECT_ID "${projectId}" was not found or you don't have access.
+Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI dashboard settings.`
+            );
+          } else if (auth.status !== 0) {
+            _connectionStatus = "degraded";
+            console.error(`[papi] \u26A0 Auth check returned ${auth.status} \u2014 running in degraded mode`);
+          }
+        } else {
+          _connectionStatus = "connected";
+          console.error("[papi] \u2713 Data proxy connected");
+          if (!_pathIdentityChecked) {
+            _pathIdentityChecked = true;
+            try {
+              const info = await adapter.getProjectInfo();
+              if (info) {
+                const cwd = options.projectRoot ?? process.env["PAPI_PROJECT_DIR"] ?? process.cwd();
+                const projectName = info.name || info.slug || projectId;
+                const result = assertWorkspaceMatch({
+                  storedPapiDir: info.papi_dir,
+                  projectName,
+                  workspacePath: cwd
+                });
+                if (result && (result.action === "backfill" || result.action === "migrate")) {
+                  try {
+                    await adapter.setProjectPapiDir(result.newPapiDir);
+                  } catch (err) {
+                    console.error(
+                      `[papi] Failed to persist papi_dir update via proxy: ${err instanceof Error ? err.message : String(err)}`
+                    );
+                  }
+                }
+              }
+            } catch (err) {
+              if (err instanceof Error && err.message.startsWith("PAPI is configured for project")) {
+                throw err;
+              }
+              console.error(
+                `[papi] \u26A0 Path-identity check skipped: ${err instanceof Error ? err.message : String(err)}`
+              );
+            }
+          }
+        }
+      } else {
+        _connectionStatus = "connected";
+        console.error("[papi] \u2713 Data proxy reachable \u2014 project will be auto-provisioned");
+      }
+      if (!projectId && connected) {
+        try {
+          const { getOriginRepoSlug: getOriginRepoSlug2, getRootCommitHash: getRootCommitHash2, getOriginUrl: getOriginUrl2 } = await Promise.resolve().then(() => (init_git(), git_exports));
+          const projectRoot = options.projectRoot ?? process.env["PAPI_PROJECT_DIR"] ?? process.cwd();
+          const repoSlug = getOriginRepoSlug2(projectRoot);
+          const projectName = repoSlug ? repoSlug.split("/").pop() || path2.basename(projectRoot) || "My Project" : path2.basename(projectRoot) || "My Project";
+          const rootHash = getRootCommitHash2(projectRoot);
+          const originUrl = getOriginUrl2(projectRoot);
+          const result = await adapter.ensureProject(projectName, originUrl ?? void 0, void 0, rootHash ?? void 0);
+          if (result.created) {
+            console.error(`[papi] \u2713 Project "${result.projectName}" auto-provisioned (${result.projectId})`);
+            console.error("[papi] Tip: add PAPI_PROJECT_ID to .mcp.json to skip this check on future starts.");
+          } else {
+            console.error(`[papi] \u2713 Using project "${result.projectName}" (${result.projectId})`);
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`[papi] \u26A0 Auto-provision failed: ${msg}`);
+          console.error("[papi] Set PAPI_PROJECT_ID in .mcp.json to connect to an existing project.");
+        }
+      }
+      return adapter;
+    }
+    default: {
+      const _exhaustive = adapterType;
+      throw new Error(
+        `Unknown PAPI_ADAPTER value: "${_exhaustive}". Valid options: "md", "pg", "proxy".`
+      );
+    }
+  }
+}
+
+// src/lib/formatters.ts
+var EFFORT_MAP = { XS: 1, S: 2, M: 3, L: 5, XL: 8 };
+function computeSnapshotsFromBuildReports(reports) {
+  if (reports.length === 0) return [];
+  const byCycleMap = /* @__PURE__ */ new Map();
+  for (const r of reports) {
+    const existing = byCycleMap.get(r.cycle) ?? [];
+    existing.push(r);
+    byCycleMap.set(r.cycle, existing);
+  }
+  const snapshots = [];
+  for (const [sn, cycleReports] of byCycleMap) {
+    const completed = cycleReports.filter((r) => r.completed === "Yes").length;
+    const total = cycleReports.length;
+    const withEffort = cycleReports.filter((r) => r.estimatedEffort && r.actualEffort);
+    const accurate = withEffort.filter((r) => r.estimatedEffort === r.actualEffort).length;
+    const matchRate = withEffort.length > 0 ? Math.round(accurate / withEffort.length * 100) : 0;
+    let effortPoints = 0;
+    for (const r of cycleReports) {
+      effortPoints += EFFORT_MAP[r.actualEffort] ?? 3;
+    }
+    snapshots.push({
+      cycle: sn,
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      accuracy: [{ cycle: sn, reports: total, matchRate, mae: 0, bias: 0 }],
+      velocity: [{ cycle: sn, completed, partial: 0, failed: total - completed, effortPoints }]
+    });
+  }
+  snapshots.sort((a, b) => a.cycle - b.cycle);
+  return snapshots;
+}
+
+// src/cli/backfill-cycle-metrics.ts
+async function runBackfillCycleMetrics(cliArgs) {
+  const dryRun = cliArgs.includes("--dry");
+  if (!process.env["DATABASE_URL"]) {
+    console.error("backfill-cycle-metrics: DATABASE_URL is required (this backfill runs against the pg adapter).");
+    return 1;
+  }
+  const adapter = await createAdapter({
+    adapterType: "pg",
+    papiDir: process.env["PAPI_PROJECT_DIR"] ?? process.cwd()
+  });
+  if (!adapter.getBuildReportsSince || !adapter.appendCycleMetrics) {
+    console.error("backfill-cycle-metrics: the resolved adapter does not support build-report reads + metric writes.");
+    return 1;
+  }
+  const reports = await adapter.getBuildReportsSince(0);
+  const snapshots = computeSnapshotsFromBuildReports(reports);
+  console.error(
+    `backfill-cycle-metrics: ${reports.length} build_report(s) \u2192 ${snapshots.length} cycle snapshot(s)${dryRun ? " [dry-run \u2014 nothing written]" : ""}.`
+  );
+  if (dryRun) {
+    for (const s of snapshots) {
+      const v = s.velocity[0];
+      const a = s.accuracy[0];
+      console.error(
+        `  C${s.cycle}: ${v?.completed ?? 0}/${a?.reports ?? 0} done, ${v?.effortPoints ?? 0}pts, ${a?.matchRate ?? 0}% est-match`
+      );
+    }
+    return 0;
+  }
+  let written = 0;
+  for (const snapshot of snapshots) {
+    await adapter.appendCycleMetrics(snapshot);
+    written++;
+  }
+  console.error(`backfill-cycle-metrics: upserted ${written} cycle snapshot(s).`);
+  return 0;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  void runBackfillCycleMetrics(process.argv.slice(2)).then((code) => process.exit(code)).catch((err) => {
+    console.error("backfill-cycle-metrics failed:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  });
+}
+export {
+  runBackfillCycleMetrics
+};