cleargate 0.8.1 → 0.10.0

package/templates/cleargate-planning/.cleargate/scripts/dedupe_frontmatter.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+/**
+ * dedupe_frontmatter.mjs — BUG-025
+ *
+ * One-shot corpus dedupe pass: scan every .md file under
+ * .cleargate/delivery/pending-sync/ and .cleargate/delivery/archive/.
+ * For any file whose YAML frontmatter contains duplicate top-level keys,
+ * keep the LAST occurrence of each key (closest to the body — this is what
+ * the stamp hook writes most recently) and rewrite the file.
+ *
+ * Idempotent: re-running produces zero diff when no duplicates remain.
+ *
+ * Usage:
+ *   node .cleargate/scripts/dedupe_frontmatter.mjs [--dry-run] [<dir>]
+ *
+ *   --dry-run   Print which files would be rewritten without writing.
+ *   <dir>       Walk only this directory instead of the canonical corpus dirs.
+ *               Used by integration tests targeting a tmpdir.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as url from 'node:url';
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+
+const args = process.argv.slice(2);
+const DRY_RUN = args.includes('--dry-run');
+const DIR_ARG = args.find((a) => !a.startsWith('--'));
+
+const PENDING_SYNC = path.join(REPO_ROOT, '.cleargate', 'delivery', 'pending-sync');
+const ARCHIVE = path.join(REPO_ROOT, '.cleargate', 'delivery', 'archive');
+
+/**
+ * Collect all .md files in a flat directory (non-recursive — delivery dirs are flat).
+ */
+function collectMd(dir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries
+    .filter((e) => e.isFile() && e.name.endsWith('.md'))
+    .map((e) => path.join(dir, e.name));
+}
+
+/**
+ * Parse a raw markdown string into:
+ *   fmLines  — the lines between the opening and closing `---` delimiters
+ *   closeIdx — index of the closing `---` line (in the full `lines` array)
+ *   lines    — all lines of the file
+ *
+ * Returns null if the file has no valid frontmatter.
+ */
+function parseFmLines(raw) {
+  const lines = raw.split('\n');
+  if (lines[0] !== '---') return null;
+  let closeIdx = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i] === '---') {
+      closeIdx = i;
+      break;
+    }
+  }
+  if (closeIdx === -1) return null;
+  return { lines, closeIdx, fmLines: lines.slice(1, closeIdx) };
+}
+
+/**
+ * Given the frontmatter lines, detect duplicate top-level keys.
+ * Returns a Map from key → array of line-indices (within fmLines) where it appears.
+ * Only entries with ≥2 occurrences indicate duplicates.
+ *
+ * A "top-level key" is a line that starts with a non-space character followed by
+ * `:<space>` or `:<end-of-line>`. Multi-line values (YAML scalars, blocks) that
+ * contain `:` on continuation lines are NOT top-level keys (they start with space/tab).
+ */
+function findDuplicateKeys(fmLines) {
+  /** @type {Map<string, number[]>} */
+  const keyMap = new Map();
+  for (let i = 0; i < fmLines.length; i++) {
+    const line = fmLines[i];
+    // Top-level key: starts at column 0, has `:` after a word character sequence
+    const m = line.match(/^([A-Za-z_][A-Za-z0-9_]*):/);
+    if (m) {
+      const key = m[1];
+      if (!keyMap.has(key)) {
+        keyMap.set(key, []);
+      }
+      keyMap.get(key).push(i);
+    }
+  }
+  // Return only keys with duplicates
+  /** @type {Map<string, number[]>} */
+  const dupes = new Map();
+  for (const [k, indices] of keyMap) {
+    if (indices.length > 1) {
+      dupes.set(k, indices);
+    }
+  }
+  return dupes;
+}
+
+/**
+ * Deduplicate frontmatter lines: for each duplicate key, keep the LAST occurrence
+ * and discard all earlier ones (including their potential multi-line values).
+ *
+ * Multi-line value detection: lines that follow a key line and start with
+ * whitespace (` ` or `\t`) belong to the preceding key's value.
+ *
+ * Returns the deduplicated fmLines array (may be the same reference if no changes).
+ */
+function dedupeLines(fmLines, dupes) {
+  if (dupes.size === 0) return fmLines;
+
+  // Build a set of fmLine indices to DROP (all but the last occurrence of each dup key,
+  // including their continuation lines).
+  /** @type {Set<number>} */
+  const dropSet = new Set();
+
+  for (const [, indices] of dupes) {
+    // Keep last occurrence; drop all earlier ones (+ their continuations)
+    const toRemove = indices.slice(0, -1); // all but last
+    for (const startIdx of toRemove) {
+      dropSet.add(startIdx);
+      // Mark continuation lines (indent-starting lines following a key line)
+      let j = startIdx + 1;
+      while (j < fmLines.length && /^[ \t]/.test(fmLines[j])) {
+        dropSet.add(j);
+        j++;
+      }
+    }
+  }
+
+  return fmLines.filter((_, i) => !dropSet.has(i));
+}
+
+/**
+ * Atomic write: write to a .tmp file then rename over the target.
+ */
+function writeAtomic(filePath, content) {
+  const tmpPath = `${filePath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tmpPath, content, 'utf8');
+  fs.renameSync(tmpPath, filePath);
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+const files = DIR_ARG
+  ? collectMd(path.resolve(DIR_ARG))
+  : [...collectMd(PENDING_SYNC), ...collectMd(ARCHIVE)];
+
+let rewritten = 0;
+let skipped = 0;
+let errors = 0;
+
+for (const filePath of files) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, 'utf8');
+  } catch (e) {
+    console.error(`error reading ${filePath}: ${e.message}`);
+    errors++;
+    continue;
+  }
+
+  const parsed = parseFmLines(raw);
+  if (!parsed) {
+    skipped++;
+    continue;
+  }
+
+  const { lines, closeIdx, fmLines } = parsed;
+  const dupes = findDuplicateKeys(fmLines);
+
+  if (dupes.size === 0) {
+    skipped++;
+    continue;
+  }
+
+  const relPath = path.relative(REPO_ROOT, filePath);
+  const dupeSummary = Array.from(dupes.keys()).join(', ');
+
+  if (DRY_RUN) {
+    console.log(`would-rewrite: ${relPath} (duplicate keys: ${dupeSummary})`);
+    rewritten++;
+    continue;
+  }
+
+  // Build the new file content: deduplicated frontmatter + rest unchanged
+  const cleanedFmLines = dedupeLines(fmLines, dupes);
+  const newLines = [
+    lines[0],            // opening ---
+    ...cleanedFmLines,
+    lines[closeIdx],     // closing ---
+    ...lines.slice(closeIdx + 1),
+  ];
+  const newContent = newLines.join('\n');
+
+  // Verify the result is actually different (guard against no-op edge cases)
+  if (newContent === raw) {
+    skipped++;
+    continue;
+  }
+
+  writeAtomic(filePath, newContent);
+  console.log(`rewritten: ${relPath} (removed duplicate keys: ${dupeSummary})`);
+  rewritten++;
+}
+
+console.log(
+  `\nDedupe complete: ${rewritten} ${DRY_RUN ? 'would-rewrite' : 'rewritten'}, ${skipped} skipped, ${errors} errors.`,
+);
+if (errors > 0) {
+  process.exit(1);
+}

package/templates/cleargate-planning/.cleargate/scripts/lib/report-filename.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+/**
+ * report-filename.mjs — Shared helper for computing the sprint report filename.
+ *
+ * Named export only — no default.
+ *
+ * Dependencies: node:path, node:fs only. No third-party deps.
+ *
+ * Design notes:
+ *   - Helper is pure given its arguments + a filesystem read (when opts.forRead=true).
+ *   - Never throws — callers decide whether to fs.readFileSync and handle ENOENT.
+ *   - Never reads env vars. Sprint dir resolution stays in callers.
+ *     (Each consumer owns CLEARGATE_SPRINT_DIR resolution.)
+ */
+
+import path from 'node:path';
+import fs from 'node:fs';
+
+/**
+ * Compute the report filename for a given sprint directory + sprint ID.
+ *
+ * New naming (SPRINT-18+): SPRINT-<#>_REPORT.md where <#> is the numeric
+ *   portion of the sprint-id (e.g. "18" for "SPRINT-18").
+ * No-numeric-portion ids (e.g. "SPRINT-TEST") → plain REPORT.md.
+ *
+ * Backwards-compat read-fallback: when opts.forRead === true AND the new-name
+ *   file is absent BUT legacy REPORT.md exists, return the legacy path.
+ *   Covers SPRINT-01..17 archives written before STORY-025-03's naming change.
+ *   MUST NOT rename or rewrite those pre-existing files.
+ *
+ * @param {string} sprintDirPath  absolute path to the sprint directory
+ * @param {string} sprintId       e.g. "SPRINT-18" or "SPRINT-TEST"
+ * @param {{ forRead?: boolean }} [opts]
+ * @returns {string} absolute path to the report file
+ */
+export function reportFilename(sprintDirPath, sprintId, opts) {
+  const numMatch = sprintId.match(/^SPRINT-(\d+)$/);
+  if (!numMatch) {
+    // No numeric portion — use plain REPORT.md (e.g. SPRINT-TEST)
+    return path.join(sprintDirPath, 'REPORT.md');
+  }
+  const sprintNumber = numMatch[1];
+  const newName = path.join(sprintDirPath, `SPRINT-${sprintNumber}_REPORT.md`);
+
+  // Read-fallback: if the new-name file doesn't exist but legacy REPORT.md does, use legacy.
+  if (opts?.forRead) {
+    const legacyName = path.join(sprintDirPath, 'REPORT.md');
+    if (!fs.existsSync(newName) && fs.existsSync(legacyName)) {
+      return legacyName;
+    }
+  }
+
+  return newName;
+}

package/templates/cleargate-planning/.cleargate/scripts/prep_doc_refresh.mjs

@@ -0,0 +1,378 @@
+#!/usr/bin/env node
+/**
+ * prep_doc_refresh.mjs <sprint-id>
+ *
+ * Generates a per-sprint tailored doc-refresh checklist by scanning what
+ * changed in the sprint window and matching trigger patterns from the
+ * canonical checklist at .cleargate/knowledge/sprint-closeout-checklist.md.
+ *
+ * Output: .cleargate/sprint-runs/<sprint-id>/.doc-refresh-checklist.md
+ *
+ * Each canonical-checklist category is evaluated; items where the trigger
+ * pattern matches at least one changed file get `- [ ]`; items where it
+ * does not get `- [x] — no changes detected, skip`.
+ *
+ * Does NOT modify any documentation. Application is human-driven.
+ *
+ * Exit codes:
+ *   0 — success
+ *   1 — sprint state.json not found (sprint dir missing)
+ *   2 — usage error (missing sprint-id argument)
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+
+/** @typedef {{ surface: string, trigger: RegExp | null, triggerDesc: string }} Item */
+/** @typedef {{ name: string, items: Item[] }} Category */
+
+/** @type {Category[]} */
+const CATEGORIES = [
+  {
+    name: '1. Project READMEs',
+    items: [
+      {
+        surface: '`README.md`',
+        trigger: /^README\.md$/,
+        triggerDesc: 'any feature that changes user-visible product behavior',
+      },
+      {
+        surface: '`cleargate-cli/README.md`',
+        trigger: /^cleargate-cli\/src\/commands\//,
+        triggerDesc: 'any change to cleargate-cli/src/commands/*.ts',
+      },
+      {
+        surface: '`cleargate-planning/README.md`',
+        trigger: /^cleargate-planning\//,
+        triggerDesc: 'any change under cleargate-planning/',
+      },
+      {
+        surface: '`mcp/README.md`',
+        trigger: /^mcp\/src\//,
+        triggerDesc: 'any change under mcp/src/ (nested repo — check separately)',
+      },
+      {
+        surface: '`admin/README.md`',
+        trigger: /^admin\//,
+        triggerDesc: 'any change under admin/ (currently stub)',
+      },
+    ],
+  },
+  {
+    name: '2. CHANGELOG files (Common-Changelog format per STORY-016-03)',
+    items: [
+      {
+        surface: '`cleargate-cli/CHANGELOG.md`',
+        trigger: /^cleargate-cli\//,
+        triggerDesc: 'any user-visible change in cleargate-cli/ (CLI surface, error messages, package contents)',
+      },
+      {
+        surface: '`mcp/CHANGELOG.md`',
+        trigger: /^mcp\//,
+        triggerDesc: 'any user-visible change in mcp/ (if file exists)',
+      },
+    ],
+  },
+  {
+    name: '3. Manifest / package metadata',
+    items: [
+      {
+        surface: '`cleargate-planning/MANIFEST.json`',
+        trigger: /^(\.claude\/agents\/|\.cleargate\/templates\/|\.cleargate\/knowledge\/|\.cleargate\/scripts\/)/,
+        triggerDesc: 'any change to .claude/agents/*.md, .cleargate/templates/*, .cleargate/knowledge/*, or .cleargate/scripts/*',
+      },
+      {
+        surface: '`cleargate-cli/package.json` (version bump)',
+        trigger: /^cleargate-cli\//,
+        triggerDesc: 'only if releasing this sprint (release lane is separate from sprint close)',
+      },
+      {
+        surface: '`mcp/package.json` (version bump)',
+        trigger: /^mcp\//,
+        triggerDesc: 'only if releasing this sprint',
+      },
+    ],
+  },
+  {
+    name: '4. CLAUDE.md "Active state" subsection',
+    items: [
+      {
+        surface: '`CLAUDE.md` "Active state" section',
+        trigger: /\.(cleargate\/delivery\/archive\/|cleargate\/delivery\/pending-sync\/)/,
+        triggerDesc: 'any EPIC / CR / Bug / Hotfix archived this sprint, OR any stack version bumped',
+      },
+      {
+        surface: '`cleargate-planning/CLAUDE.md` mirror',
+        trigger: /\.(cleargate\/delivery\/archive\/|cleargate\/delivery\/pending-sync\/)/,
+        triggerDesc: 'same edit as live (CLEARGATE-tag-block region only — outside-block diverges intentionally)',
+      },
+    ],
+  },
+  {
+    name: '5. Wiki surfaces (auto-rebuilt by PostToolUse hooks; verify after close)',
+    items: [
+      {
+        surface: '`.cleargate/wiki/active-sprint.md`',
+        trigger: null,
+        triggerDesc: 'always verify at sprint close — confirm sprint ID, status, and date are current',
+      },
+      {
+        surface: '`.cleargate/wiki/index.md`',
+        trigger: null,
+        triggerDesc: 'always verify at sprint close — confirm new artifacts appear in relevant sections',
+      },
+      {
+        surface: '`.cleargate/wiki/product-state.md`',
+        trigger: null,
+        triggerDesc: 'always verify at sprint close — confirm shipped capabilities are listed',
+      },
+      {
+        surface: '`.cleargate/wiki/roadmap.md`',
+        trigger: null,
+        triggerDesc: 'always verify at sprint close — confirm closed sprint moved from Active to Completed',
+      },
+    ],
+  },
+  {
+    name: '6. INDEX surfaces (manual updates)',
+    items: [
+      {
+        surface: '`.cleargate/INDEX.md`',
+        trigger: null,
+        triggerDesc: 'if maintained as a curated roadmap; update when sprint closes',
+      },
+      {
+        surface: '`.cleargate/delivery/INDEX.md`',
+        trigger: null,
+        triggerDesc: 'update epic/sprint map when new artifacts archived',
+      },
+    ],
+  },
+  {
+    name: '7. Frontmatter version stamps',
+    items: [
+      {
+        surface: 'Modified `.cleargate/templates/*.md` (run `cleargate stamp <path>`)',
+        trigger: /^\.cleargate\/templates\//,
+        triggerDesc: 'any .cleargate/templates/*.md modified this sprint',
+      },
+      {
+        surface: '`.cleargate/knowledge/cleargate-protocol.md` (run `cleargate stamp`)',
+        trigger: /^\.cleargate\/knowledge\/cleargate-protocol\.md$/,
+        triggerDesc: 'if cleargate-protocol.md was modified this sprint (post-EPIC-024 slim)',
+      },
+      {
+        surface: '`.cleargate/knowledge/cleargate-enforcement.md` (run `cleargate stamp`)',
+        trigger: /^\.cleargate\/knowledge\/cleargate-enforcement\.md$/,
+        triggerDesc: 'if cleargate-enforcement.md was modified this sprint (post-EPIC-024 split)',
+      },
+      {
+        surface: 'Other modified `.cleargate/knowledge/*.md` (run `cleargate stamp <path>`)',
+        trigger: /^\.cleargate\/knowledge\//,
+        triggerDesc: 'any other .cleargate/knowledge/*.md touched this sprint',
+      },
+    ],
+  },
+  {
+    name: '8. Knowledge doc cross-references',
+    items: [
+      {
+        surface: 'Knowledge docs citing `§N` of protocol or enforcement.md',
+        trigger: /^\.cleargate\/knowledge\//,
+        triggerDesc: 'any knowledge doc modified — verify §N citations still resolve post-rewrite',
+      },
+    ],
+  },
+  {
+    name: '9. Mirror parity audit',
+    items: [
+      {
+        surface: '`cleargate-planning/.claude/agents/` diff',
+        trigger: /^\.claude\/agents\//,
+        triggerDesc: 'any change to .claude/agents/*.md — run diff -r to verify parity',
+      },
+      {
+        surface: '`cleargate-planning/.cleargate/templates/` diff',
+        trigger: /^\.cleargate\/templates\//,
+        triggerDesc: 'any change to .cleargate/templates/ — run diff -r to verify parity',
+      },
+      {
+        surface: '`cleargate-planning/.cleargate/knowledge/` diff',
+        trigger: /^\.cleargate\/knowledge\//,
+        triggerDesc: 'any change to .cleargate/knowledge/ — run diff -r to verify parity',
+      },
+    ],
+  },
+];
+
+/**
+ * Get changed files for a sprint using available strategies.
+ * Strategy 1: git log sprint/<sprint-id> ^main --name-only (if branch exists)
+ * Strategy 2: git log --since <start_date> --name-only (from sprint frontmatter)
+ * Strategy 3: git log --grep <sprint-id> --name-only (commit-message grep fallback)
+ *
+ * @param {string} sprintId
+ * @param {string} sprintDir
+ * @returns {string[]} deduped array of changed file paths
+ */
+function getChangedFiles(sprintId, sprintDir) {
+  // Strategy 1: sprint branch
+  try {
+    const branchCheck = execSync(`git rev-parse --verify "refs/heads/sprint/${sprintId}"`, {
+      cwd: REPO_ROOT,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).toString().trim();
+    if (branchCheck) {
+      const out = execSync(
+        `git log "sprint/${sprintId}" ^main --name-only --format=""`,
+        { cwd: REPO_ROOT, stdio: ['pipe', 'pipe', 'pipe'] }
+      ).toString();
+      const files = out.split('\n').map(f => f.trim()).filter(Boolean);
+      if (files.length > 0) {
+        return [...new Set(files)];
+      }
+    }
+  } catch {
+    // branch does not exist — fall through to next strategy
+  }
+
+  // Strategy 2: --since <start_date> from sprint frontmatter
+  const startDate = readStartDateFromFrontmatter(sprintId);
+  if (startDate) {
+    try {
+      const out = execSync(
+        `git log --since="${startDate}" --name-only --format=""`,
+        { cwd: REPO_ROOT, stdio: ['pipe', 'pipe', 'pipe'] }
+      ).toString();
+      const files = out.split('\n').map(f => f.trim()).filter(Boolean);
+      if (files.length > 0) {
+        return [...new Set(files)];
+      }
+    } catch {
+      // fall through to strategy 3
+    }
+  }
+
+  // Strategy 3: commit-message grep for sprint ID
+  try {
+    const out = execSync(
+      `git log --grep="${sprintId}" --name-only --format=""`,
+      { cwd: REPO_ROOT, stdio: ['pipe', 'pipe', 'pipe'] }
+    ).toString();
+    const files = out.split('\n').map(f => f.trim()).filter(Boolean);
+    return [...new Set(files)];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Read start_date from sprint frontmatter file.
+ * Looks in pending-sync first, then archive.
+ *
+ * @param {string} sprintId
+ * @returns {string | null}
+ */
+function readStartDateFromFrontmatter(sprintId) {
+  const dirs = [
+    path.join(REPO_ROOT, '.cleargate', 'delivery', 'pending-sync'),
+    path.join(REPO_ROOT, '.cleargate', 'delivery', 'archive'),
+  ];
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) continue;
+    const entries = fs.readdirSync(dir);
+    const match = entries.find(e => e.startsWith(`${sprintId}_`) && e.endsWith('.md'));
+    if (match) {
+      const content = fs.readFileSync(path.join(dir, match), 'utf8');
+      const m = content.match(/^start_date:\s*["']?(.+?)["']?\s*$/m);
+      if (m) return m[1].trim();
+    }
+  }
+  return null;
+}
+
+/**
+ * Evaluate each checklist category against the changed file set.
+ *
+ * @param {string[]} changedFiles
+ * @returns {{ category: Category, results: Array<{ item: Item, triggered: boolean }> }[]}
+ */
+function evaluateChecklist(changedFiles) {
+  return CATEGORIES.map(category => ({
+    category,
+    results: category.items.map(item => ({
+      item,
+      triggered: item.trigger === null
+        ? true  // null trigger = always review
+        : changedFiles.some(f => item.trigger.test(f)),
+    })),
+  }));
+}
+
+/**
+ * Render the checklist markdown.
+ *
+ * @param {ReturnType<typeof evaluateChecklist>} evaluation
+ * @param {string} sprintId
+ * @returns {string}
+ */
+function renderChecklist(evaluation, sprintId) {
+  const lines = [
+    `# Doc & Metadata Refresh Checklist — ${sprintId}`,
+    '',
+    `> Generated by \`prep_doc_refresh.mjs\` at ${new Date().toISOString()}.`,
+    '> Each item is pre-evaluated against the sprint\'s changed file set.',
+    '> `- [ ]` = action required; `- [x]` = no changes detected, skip.',
+    '> Apply or defer each `- [ ]` item during Gate 4 ack.',
+    '> Canonical checklist: `.cleargate/knowledge/sprint-closeout-checklist.md`',
+    '',
+  ];
+
+  for (const { category, results } of evaluation) {
+    lines.push(`### ${category.name}`);
+    lines.push('');
+    for (const { item, triggered } of results) {
+      if (triggered) {
+        lines.push(`- [ ] ${item.surface} — **trigger:** ${item.triggerDesc}`);
+      } else {
+        lines.push(`- [x] ${item.surface} — no changes detected, skip`);
+      }
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+function main() {
+  const sprintId = process.argv[2];
+  if (!sprintId) {
+    console.error('Usage: prep_doc_refresh.mjs <sprint-id>');
+    console.error('Example: prep_doc_refresh.mjs SPRINT-16');
+    process.exit(2);
+  }
+
+  const sprintDir = path.join(REPO_ROOT, '.cleargate', 'sprint-runs', sprintId);
+  if (!fs.existsSync(sprintDir)) {
+    console.error(`Error: sprint state.json not found at ${path.join(sprintDir, 'state.json')}`);
+    console.error(`Sprint directory does not exist: ${sprintDir}`);
+    process.exit(1);
+  }
+
+  const changedFiles = getChangedFiles(sprintId, sprintDir);
+  console.log(`Found ${changedFiles.length} changed files in sprint window.`);
+
+  const evaluation = evaluateChecklist(changedFiles);
+  const markdown = renderChecklist(evaluation, sprintId);
+
+  const outFile = path.join(sprintDir, '.doc-refresh-checklist.md');
+  fs.writeFileSync(outFile, markdown, 'utf8');
+  console.log(`Wrote ${outFile}`);
+}
+
+main();