@ryuenn3123/agentic-senior-core 4.0.2 → 4.1.0

package/scripts/frontend-usability-audit.mjs

@@ -17,9 +17,7 @@ const __dirname = dirname(__filename);
 const REPOSITORY_ROOT = resolve(__dirname, '..');
 
 const REQUIRED_FILES = [
-  'docs/roadmap.md',
-  'docs/archive/v1.7-issue-breakdown.md',
-  'docs/archive/v1.7-execution-playbook.md',
+  'docs/archive/HISTORY.md',
   'AGENTS.md',
   '.agent-context/prompts/bootstrap-design.md',
   'scripts/ui-design-judge.mjs',
@@ -32,11 +30,10 @@ const REQUIRED_FILES = [
   'lib/cli/detector/design-evidence.mjs',
 ];
 
-const REQUIRED_ROADMAP_SNIPPETS = [
+const REQUIRED_HISTORY_SNIPPETS = [
   'V1.7',
   'Frontend Product Experience',
-  'Release status: Completed',
-  'Delivered Scope',
+  'completed',
 ];
 
 const REQUIRED_PR_CHECKLIST_SNIPPETS = [
@@ -174,7 +171,7 @@ function runAudit() {
     assertFileExists(requiredFilePath, failures);
   }
 
-  const roadmapPath = 'docs/roadmap.md';
+  const roadmapPath = 'docs/archive/HISTORY.md';
   const frontendRulePath = '.agent-context/rules/frontend-architecture.md';
   const bootstrapDesignPromptPath = '.agent-context/prompts/bootstrap-design.md';
   const instructionsPath = 'AGENTS.md';
@@ -185,7 +182,7 @@ function runAudit() {
 
   if (existsSync(resolve(REPOSITORY_ROOT, roadmapPath))) {
     const roadmapContent = readFileSync(resolve(REPOSITORY_ROOT, roadmapPath), 'utf8');
-    assertContains('Roadmap', roadmapPath, roadmapContent, REQUIRED_ROADMAP_SNIPPETS, failures);
+    assertContains('Project history', roadmapPath, roadmapContent, REQUIRED_HISTORY_SNIPPETS, failures);
   }
 
   if (existsSync(resolve(REPOSITORY_ROOT, prChecklistPath))) {

package/scripts/release-gate/static-checks.mjs

@@ -23,7 +23,6 @@ import {
 export function runStaticReleaseChecks(results, diagnostics) {
   const packageJsonPath = 'package.json';
   const changelogPath = 'CHANGELOG.md';
-  const roadmapPath = 'docs/roadmap.md';
 
   const packageJsonContent = readText(packageJsonPath);
   if (!packageJsonContent) {
@@ -61,13 +60,14 @@ export function runStaticReleaseChecks(results, diagnostics) {
     pushResult(results, true, 'changelog-version-entry', `Found release header for ${releaseVersion}`);
   }
 
-  const roadmapContent = readText(roadmapPath);
-  if (!roadmapContent) {
-    pushResult(results, false, 'roadmap-exists', `Missing ${roadmapPath}`);
-  } else if (!roadmapContent.includes('V1.8')) {
-    pushResult(results, false, 'roadmap-v18', 'Roadmap does not mention V1.8 release track');
+  const historyPath = 'docs/archive/HISTORY.md';
+  const historyContent = readText(historyPath);
+  if (!historyContent) {
+    pushResult(results, false, 'history-exists', `Missing ${historyPath}`);
+  } else if (!historyContent.includes('V1.8')) {
+    pushResult(results, false, 'history-v18', 'Project history does not mention V1.8 release track');
   } else {
-    pushResult(results, true, 'roadmap-v18', 'Roadmap includes V1.8 release track');
+    pushResult(results, true, 'history-v18', 'Project history includes V1.8 release track');
   }
 
   try {

package/scripts/validate/config.mjs

@@ -51,7 +51,6 @@ export const REQUIRED_HUMAN_WRITING_SNIPPETS = [
 ];
 export const TERMINOLOGY_REFERENCE_PATHS = [
   'README.md',
-  'docs/roadmap.md',
 ];
 export const REQUIRED_TERMINOLOGY_ROW_PATTERNS = [
   {
@@ -69,7 +68,6 @@ export const REQUIRED_TERMINOLOGY_ROW_PATTERNS = [
 ];
 export const REQUIRED_TERMINOLOGY_RULE_SNIPPET =
   'Rule: on first mention in developer-facing docs, include canonical term in parentheses.';
-export const TERMINOLOGY_REFERENCE_DOCUMENT_PATH = 'docs/terminology-mapping.md';
 export const REQUIRED_DEVELOPER_FIRST_MENTION_PATTERNS = [
   {
     path: 'README.md',

package/scripts/validate/coverage-checks.mjs

@@ -19,7 +19,6 @@ import {
   REQUIRED_UI_DESIGN_AUTOMATION_SNIPPETS,
   REQUIRED_UNIVERSAL_SOP_SNIPPETS,
   REQUIRED_UPGRADE_UI_CONTRACT_WARNING_SNIPPETS,
-  TERMINOLOGY_REFERENCE_DOCUMENT_PATH,
   TERMINOLOGY_REFERENCE_PATHS,
   THIN_ADAPTER_PATHS,
 } from './config.mjs';
@@ -59,40 +58,6 @@ export async function validateTerminologyMapping(context) {
 
   console.log('\nChecking terminology mapping consistency...');
 
-  const terminologyReferenceDocumentPath = join(ROOT_DIR, TERMINOLOGY_REFERENCE_DOCUMENT_PATH);
-
-  if (!(await fileExists(terminologyReferenceDocumentPath))) {
-    fail(`Missing terminology reference document: ${TERMINOLOGY_REFERENCE_DOCUMENT_PATH}`);
-  } else {
-    const terminologyReferenceContent = await readTextFile(terminologyReferenceDocumentPath);
-
-    if (terminologyReferenceContent.includes('Dual-Term Mapping')) {
-      pass(`${TERMINOLOGY_REFERENCE_DOCUMENT_PATH} includes Dual-Term Mapping section`);
-    } else {
-      fail(`${TERMINOLOGY_REFERENCE_DOCUMENT_PATH} must include Dual-Term Mapping section`);
-    }
-
-    for (const terminologyRowRule of REQUIRED_TERMINOLOGY_ROW_PATTERNS) {
-      if (terminologyRowRule.pattern.test(terminologyReferenceContent)) {
-        pass(`${TERMINOLOGY_REFERENCE_DOCUMENT_PATH} includes mapping row: ${terminologyRowRule.label}`);
-      } else {
-        fail(`${TERMINOLOGY_REFERENCE_DOCUMENT_PATH} is missing mapping row: ${terminologyRowRule.label}`);
-      }
-    }
-
-    if (terminologyReferenceContent.includes('first mention must include canonical term in parentheses')) {
-      pass(`${TERMINOLOGY_REFERENCE_DOCUMENT_PATH} defines first-mention canonical term rule`);
-    } else {
-      fail(`${TERMINOLOGY_REFERENCE_DOCUMENT_PATH} must define first-mention canonical term rule`);
-    }
-
-    if (terminologyReferenceContent.includes('Formal policy and audit artifacts must keep canonical terminology')) {
-      pass(`${TERMINOLOGY_REFERENCE_DOCUMENT_PATH} defines compliance terminology boundary`);
-    } else {
-      fail(`${TERMINOLOGY_REFERENCE_DOCUMENT_PATH} must define compliance terminology boundary`);
-    }
-  }
-
   for (const terminologyReferencePath of TERMINOLOGY_REFERENCE_PATHS) {
     const absoluteReferencePath = join(ROOT_DIR, terminologyReferencePath);
 
@@ -122,12 +87,6 @@ export async function validateTerminologyMapping(context) {
     } else {
       fail(`${terminologyReferencePath} must include first-mention canonical term rule`);
     }
-
-    if (referenceContent.includes(TERMINOLOGY_REFERENCE_DOCUMENT_PATH)) {
-      pass(`${terminologyReferencePath} links to ${TERMINOLOGY_REFERENCE_DOCUMENT_PATH}`);
-    } else {
-      fail(`${terminologyReferencePath} must link to ${TERMINOLOGY_REFERENCE_DOCUMENT_PATH}`);
-    }
   }
 
   for (const firstMentionRule of REQUIRED_DEVELOPER_FIRST_MENTION_PATTERNS) {
@@ -397,7 +356,7 @@ export async function validateInstructionAdapters(context) {
   const instructionFootprintLimits = [
     { path: 'AGENTS.md', maxLines: 180 },
     { path: '.agent-context/prompts/bootstrap-design.md', maxLines: 180 },
-    { path: '.agent-context/rules/frontend-architecture.md', maxLines: 140 },
+    { path: '.agent-context/rules/frontend-architecture.md', maxLines: 180 },
   ];
 
   for (const requiredBootstrapReceiptSnippet of requiredBootstrapReceiptSnippets) {

package/scripts/validate.mjs

@@ -20,6 +20,7 @@ import { fileURLToPath } from 'node:url';
 import { ALLOWED_SEVERITIES } from './validate/config.mjs';
 import { runCacheLayerContractAudit } from './audit-cache-layer-contract.mjs';
 import { runCachingScopeHygieneAudit } from './audit-caching-scope-hygiene.mjs';
+import { runTypographyPaletteAntiRepeatAudit } from '../lib/cli/audits/typography-palette-anti-repeat-audit.mjs';
 import { runAuditFileSize } from './audit-file-size.mjs';
 import { runReflectionCitationAudit } from './audit-reflection-citations.mjs';
 import { runReleaseBundleAudit } from './audit-release-bundle.mjs';
@@ -153,8 +154,10 @@ async function validateRequiredFiles() {
     'scripts/explain-on-demand-audit.mjs',
     'scripts/single-source-lazy-loading-audit.mjs',
     'scripts/audit-cache-layer-contract.mjs',
+    'scripts/audit-typography-palette-anti-repeat.mjs',
+    'lib/cli/audits/typography-palette-anti-repeat-audit.mjs',
+    'lib/cli/commands/audit-design-anti-repeat.mjs',
     'scripts/sync-thin-adapters.mjs',
-    'scripts/v3-purge-audit.mjs',
     'scripts/release-gate.mjs',
     'scripts/generate-sbom.mjs',
     '.agent-context/policies/llm-judge-threshold.json',
@@ -171,11 +174,8 @@ async function validateRequiredFiles() {
     'docs/api-contract.md',
     'docs/faq.md',
     'docs/deep-dive.md',
-    'docs/terminology-mapping.md',
-    'docs/archive/v1.7-execution-playbook.md',
-    'docs/archive/v1.7-issue-breakdown.md',
-    'docs/archive/v1.8-operations-playbook.md',
-    'docs/archive/v2-upgrade-playbook.md',
+    'docs/archive/HISTORY.md',
+    'docs/archive/CHANGELOG-archive.md',
     '.agent-context/state/benchmark-reproducibility.json',
     '.agent-context/state/benchmark-writer-judge-config.json',
     '.agent-context/state/memory-schema-v1.json',
@@ -243,6 +243,12 @@ async function validateRuleFiles() {
     'rules/realtime.md',
     'rules/frontend-architecture.md',
     'rules/docker-runtime.md',
+    'rules/observability.md',
+    'rules/resilience.md',
+    'rules/migrations.md',
+    'rules/background-jobs.md',
+    'rules/config-and-flags.md',
+    'rules/api-versioning.md',
     'review-checklists/pr-checklist.md',
     'review-checklists/architecture-review.md',
     'prompts/init-project.md',
@@ -492,7 +498,7 @@ async function validateDocumentationFlow() {
     'npm run validate',
     'docs/faq.md',
     'docs/deep-dive.md',
-    'docs/archive/v2-upgrade-playbook.md',
+    'docs/archive/HISTORY.md',
   ];
 
   for (const requiredReadmeSnippet of requiredReadmeSnippets) {
@@ -569,6 +575,34 @@ async function validateCachingScopeHygieneAudit() {
   }
 }
 
+async function validateTypographyPaletteAntiRepeatAudit() {
+  console.log('\nChecking typography and palette anti-repeat ledger (audit:typography-palette-anti-repeat)...');
+  const report = runTypographyPaletteAntiRepeatAudit({ repositoryRootPath: ROOT_DIR });
+
+  if (report.skipped) {
+    pass(`Typography/palette anti-repeat audit skipped: ${report.reason}`);
+    return;
+  }
+
+  if (report.passed) {
+    pass(`Typography/palette anti-repeat audit clean: ${report.filesScanned} CSS/token file(s) scanned, 0 blocking typography violation(s), ${report.paletteFindingCount} palette finding(s) (${report.paletteSeverity})`);
+    return;
+  }
+
+  for (const violation of report.typographyViolations) {
+    fail(`Typography ledger violation [${violation.kind}] in ${violation.file}:${violation.line}: ${violation.detail}`);
+  }
+  if (report.paletteSeverity === 'blocking') {
+    for (const finding of report.paletteFindings) {
+      fail(`Palette ledger violation [${finding.kind}] in ${finding.file}:${finding.line}: ${finding.detail}`);
+    }
+  } else {
+    for (const finding of report.paletteFindings) {
+      warn(`Palette ledger advisory [${finding.kind}] in ${finding.file}:${finding.line}: ${finding.detail}`);
+    }
+  }
+}
+
 async function validateReleaseBundleAudit() {
   console.log('\nChecking release benchmark bundle (audit:release-bundle)...');
   const report = runReleaseBundleAudit();
@@ -666,6 +700,7 @@ async function main() {
   await validateCacheLayerContractAudit();
   await validateReflectionCitationAudit();
   await validateCachingScopeHygieneAudit();
+  await validateTypographyPaletteAntiRepeatAudit();
   await validateReleaseBundleAudit();
   await validateFileSizeAudit();
   await validateRuleIdUniquenessAudit();

package/scripts/migrate-rule-format/id-prefix-table.mjs

@@ -1,37 +0,0 @@
-// @ts-check
-
-/**
- * Locked ID prefix table per `docs/architecture/format-spec.md` section 3.
- * The migration helper reads this map to assign frontmatter and section IDs.
- * Lock new entries here when adding a new rule file; never invent prefixes inline.
- */
-
-export const ID_PREFIX_TABLE = Object.freeze({
-  'api-docs.md': { prefix: 'API', domain: 'api-docs', priority: 'high', scope: 'backend', appliesTo: ['backend', 'fullstack'] },
-  'architecture.md': { prefix: 'ARCH', domain: 'architecture', priority: 'critical', scope: 'all-tasks', appliesTo: ['backend', 'frontend', 'fullstack'] },
-  'database-design.md': { prefix: 'DATA', domain: 'database-design', priority: 'high', scope: 'data', appliesTo: ['backend', 'fullstack'] },
-  'docker-runtime.md': { prefix: 'DOCK', domain: 'docker-runtime', priority: 'high', scope: 'infra', appliesTo: ['backend', 'frontend', 'fullstack'] },
-  'efficiency-vs-hype.md': { prefix: 'DEP', domain: 'efficiency-vs-hype', priority: 'medium', scope: 'all-tasks', appliesTo: ['backend', 'frontend', 'fullstack'] },
-  'error-handling.md': { prefix: 'ERR', domain: 'error-handling', priority: 'high', scope: 'all-tasks', appliesTo: ['backend', 'frontend', 'fullstack'] },
-  'event-driven.md': { prefix: 'EVT', domain: 'event-driven', priority: 'medium', scope: 'backend', appliesTo: ['backend', 'fullstack'] },
-  'frontend-architecture.md': { prefix: 'FE', domain: 'frontend-architecture', priority: 'high', scope: 'ui', appliesTo: ['frontend', 'fullstack'] },
-  'git-workflow.md': { prefix: 'GIT', domain: 'git-workflow', priority: 'medium', scope: 'governance', appliesTo: ['backend', 'frontend', 'fullstack'] },
-  'microservices.md': { prefix: 'SVC', domain: 'microservices', priority: 'medium', scope: 'backend', appliesTo: ['backend', 'fullstack'] },
-  'naming-conv.md': { prefix: 'NAME', domain: 'naming-conv', priority: 'medium', scope: 'all-tasks', appliesTo: ['backend', 'frontend', 'fullstack'] },
-  'performance.md': { prefix: 'PERF', domain: 'performance', priority: 'medium', scope: 'all-tasks', appliesTo: ['backend', 'frontend', 'fullstack'] },
-  'realtime.md': { prefix: 'RT', domain: 'realtime', priority: 'medium', scope: 'backend', appliesTo: ['backend', 'fullstack'] },
-  'security.md': { prefix: 'SEC', domain: 'security', priority: 'critical', scope: 'all-tasks', appliesTo: ['backend', 'frontend', 'fullstack'] },
-  'testing.md': { prefix: 'TEST', domain: 'testing', priority: 'high', scope: 'all-tasks', appliesTo: ['backend', 'frontend', 'fullstack'] },
-});
-
-/**
- * @param {string} filename
- * @returns {{ prefix: string, domain: string, priority: string, scope: string, appliesTo: string[] }}
- */
-export function getPrefixEntry(filename) {
-  const entry = ID_PREFIX_TABLE[filename];
-  if (!entry) {
-    throw new Error(`Unknown rule file '${filename}'. Add it to ID_PREFIX_TABLE before migrating.`);
-  }
-  return entry;
-}

package/scripts/migrate-rule-format/parse-legacy.mjs

@@ -1,180 +0,0 @@
-// @ts-check
-
-/**
- * Best-effort parser for the legacy v3 rule file format. Extracts:
- *   - the H1 title
- *   - an optional intro paragraph (1-3 sentences before the first H2)
- *   - a list of sections, each with H2 title + ordered content blocks
- *
- * Each content block is one of:
- *   { kind: 'paragraph', text }
- *   { kind: 'bullet-list', items: string[] }
- *   { kind: 'sub-bullet-list', items: string[] }  // legacy nested bullets
- *
- * The parser intentionally throws on shapes it cannot represent in the new
- * format. This forces the human migrator to review unusual sections instead of
- * silently losing content.
- */
-
-/**
- * @typedef {{ kind: 'paragraph', text: string }} ParagraphBlock
- * @typedef {{ kind: 'bullet-list', items: string[] }} BulletListBlock
- * @typedef {ParagraphBlock | BulletListBlock} ContentBlock
- *
- * @typedef {{
- *   title: string,
- *   blocks: ContentBlock[],
- * }} ParsedSection
- *
- * @typedef {{
- *   h1Title: string,
- *   introParagraph: string | null,
- *   sections: ParsedSection[],
- *   warnings: string[],
- * }} ParsedRuleFile
- */
-
-/**
- * @param {string} sourceText
- * @returns {ParsedRuleFile}
- */
-export function parseLegacyRuleFile(sourceText) {
-  const lines = sourceText.replace(/\r\n/g, '\n').split('\n');
-  const warnings = [];
-  const isH2 = (line) => line.startsWith('## ');
-  const isH1 = (line) => line.startsWith('# ');
-  const isColonSectionLabel = (line) => /^[A-Z][^:\n]+:$/.test(line.trim());
-
-  let cursor = 0;
-  while (cursor < lines.length && lines[cursor].trim() === '') {
-    cursor += 1;
-  }
-
-  const h1Match = (lines[cursor] || '').match(/^#\s+(.+)$/);
-  if (!h1Match) {
-    throw new Error('Legacy file missing top-level H1 heading at the first non-empty line.');
-  }
-  const h1Title = h1Match[1].trim();
-  cursor += 1;
-
-  while (cursor < lines.length && lines[cursor].trim() === '') {
-    cursor += 1;
-  }
-
-  let introParagraph = null;
-  if (cursor < lines.length && !lines[cursor].startsWith('## ') && !lines[cursor].startsWith('# ')) {
-    const introLines = [];
-    while (cursor < lines.length && !lines[cursor].startsWith('## ') && !lines[cursor].startsWith('# ')) {
-      const line = lines[cursor];
-      if (line.trim() === '' && introLines.length > 0) {
-        break;
-      }
-      if (line.trim() !== '') {
-        introLines.push(line.trim());
-      }
-      cursor += 1;
-    }
-    if (introLines.length > 0) {
-      introParagraph = introLines.join(' ').trim();
-      const sentenceCount = (introParagraph.match(/[.!?](?=\s|$)/g) || []).length;
-      if (sentenceCount > 3) {
-        warnings.push(`Intro paragraph has ${sentenceCount} sentences (max 3 per format spec). Trim or split during manual review.`);
-      }
-    }
-  }
-
-  while (cursor < lines.length && lines[cursor].trim() === '') {
-    cursor += 1;
-  }
-
-  /** @type {ParsedSection[]} */
-  const sections = [];
-  while (cursor < lines.length) {
-    while (cursor < lines.length && lines[cursor].trim() === '') {
-      cursor += 1;
-    }
-    if (cursor >= lines.length) {
-      break;
-    }
-
-    let sectionTitle = '';
-    if (isH2(lines[cursor])) {
-      sectionTitle = lines[cursor].slice(3).trim();
-      cursor += 1;
-    } else if (isColonSectionLabel(lines[cursor])) {
-      sectionTitle = lines[cursor].trim().replace(/:$/, '');
-      cursor += 1;
-    } else if (!isH1(lines[cursor])) {
-      sectionTitle = sections.length === 0 ? 'General Guidance' : 'Boundary Summary';
-    } else {
-      cursor += 1;
-      continue;
-    }
-
-    /** @type {ContentBlock[]} */
-    const blocks = [];
-    while (cursor < lines.length && !isH2(lines[cursor]) && !isH1(lines[cursor]) && !isColonSectionLabel(lines[cursor])) {
-      const line = lines[cursor];
-
-      if (line.trim() === '') {
-        cursor += 1;
-        continue;
-      }
-
-      if (/^\s*-\s+/.test(line)) {
-        const items = [];
-        let nestedItems = [];
-        while (cursor < lines.length && (/^\s*-\s+/.test(lines[cursor]) || lines[cursor].trim() === '' || /^\s{2,}\S/.test(lines[cursor]))) {
-          const bulletLine = lines[cursor];
-          if (bulletLine.trim() === '') {
-            cursor += 1;
-            if (cursor < lines.length && !/^\s*-\s+/.test(lines[cursor])) {
-              break;
-            }
-            continue;
-          }
-          const topMatch = bulletLine.match(/^-\s+(.+)$/);
-          const nestedMatch = bulletLine.match(/^\s{2,}-\s+(.+)$/);
-          const continuationMatch = bulletLine.match(/^\s{2,}(\S.+)$/);
-          if (topMatch) {
-            if (nestedItems.length > 0 && items.length > 0) {
-              items[items.length - 1] += `\n  ${nestedItems.map((nested) => `- ${nested}`).join('\n  ')}`;
-              nestedItems = [];
-            }
-            items.push(topMatch[1].trim());
-          } else if (nestedMatch) {
-            nestedItems.push(nestedMatch[1].trim());
-          } else if (continuationMatch && items.length > 0) {
-            items[items.length - 1] += ` ${continuationMatch[1].trim()}`;
-          } else {
-            break;
-          }
-          cursor += 1;
-        }
-        if (nestedItems.length > 0 && items.length > 0) {
-          items[items.length - 1] += `\n  ${nestedItems.map((nested) => `- ${nested}`).join('\n  ')}`;
-        }
-        blocks.push({ kind: 'bullet-list', items });
-        continue;
-      }
-
-      const paragraphLines = [];
-      while (
-        cursor < lines.length
-        && lines[cursor].trim() !== ''
-        && !isH2(lines[cursor])
-        && !isH1(lines[cursor])
-        && !isColonSectionLabel(lines[cursor])
-        && !/^\s*-\s+/.test(lines[cursor])
-      ) {
-        paragraphLines.push(lines[cursor].trim());
-        cursor += 1;
-      }
-      blocks.push({ kind: 'paragraph', text: paragraphLines.join(' ').trim() });
-    }
-
-    sections.push({ title: sectionTitle, blocks });
-  }
-
-  return { h1Title, introParagraph, sections, warnings };
-}

package/scripts/migrate-rule-format/render-new.mjs

@@ -1,169 +0,0 @@
-// @ts-check
-
-/**
- * Renders a parsed legacy rule file plus a prefix-table entry into the v4
- * canonical format defined in `docs/architecture/format-spec.md`.
- *
- * Section IDs auto-assign sequentially starting at 001. The renderer never
- * skips integers; humans introduce gaps manually during review by editing
- * the produced file (e.g. when expecting later splits).
- *
- * Each parsed bullet-list becomes one numbered item if it has 1-2 items, or a
- * single numbered item with sub-bullets when the list is enumerative (3+
- * items that share the same shape).
- */
-
-import { stringify as stringifyYaml } from 'yaml';
-
-function pickKeywords(parsedRuleFile, prefixEntry) {
-  // Hand-picked first: the file's id_prefix lowercased and the domain itself
-  // are always relevant. Additional keywords are drawn from the highest-signal
-  // kebab-case tokens in the H1 + section titles, capped at 6 total. The
-  // validate gate snippet checks accept either body presence or this array, so
-  // we prioritize tokens that appear in section titles (more likely to be
-  // queried) over tokens buried in paragraphs.
-  const handPicked = new Set([prefixEntry.domain, prefixEntry.prefix.toLowerCase()]);
-  const titleSignal = parsedRuleFile.h1Title + ' ' + parsedRuleFile.sections.map((section) => section.title).join(' ');
-  for (const word of titleSignal.toLowerCase().match(/[a-z][a-z0-9]+(?:-[a-z0-9]+)*/g) ?? []) {
-    if (word.length >= 4 && word.length <= 32 && handPicked.size < 6) {
-      handPicked.add(word);
-    }
-  }
-  return [...handPicked];
-}
-
-function renderFrontmatter(prefixEntry, parsedRuleFile) {
-  // Trimmed v4 frontmatter (per phase-1-format.md GATE B revision):
-  //   - drop `version` for first-time-v1 files (only meaningful when bumped)
-  //   - drop `last_migrated` (git history is the audit trail)
-  //   - cap `keywords` at 6 hand-picked entries instead of 12 auto-extracted
-  const frontmatterObject = {
-    id_prefix: prefixEntry.prefix,
-    domain: prefixEntry.domain,
-    priority: prefixEntry.priority,
-    scope: prefixEntry.scope,
-    applies_to: [...prefixEntry.appliesTo],
-    keywords: pickKeywords(parsedRuleFile, prefixEntry),
-  };
-  const yamlBody = stringifyYaml(frontmatterObject, { lineWidth: 0 }).trimEnd();
-  return `---\n${yamlBody}\n---\n`;
-}
-
-function renderIntroParagraph(parsedRuleFile) {
-  if (!parsedRuleFile.introParagraph) return '';
-  return `${parsedRuleFile.introParagraph}\n\n`;
-}
-
-// Common abbreviations that end with a period but are not sentence endings.
-// Mid-sentence occurrences like "etc. The next..." would otherwise be split
-// at the abbreviation. Pre-masking is the cheapest fix and is easy to extend.
-const NON_SENTENCE_ENDING_ABBREVIATIONS = Object.freeze(['e.g', 'i.e', 'etc', 'vs', 'cf', 'Mr', 'Dr', 'Mrs', 'Inc', 'Ltd']);
-const ABBREVIATION_MASK_TOKEN = '\u0001';
-
-function maskAbbreviationPeriods(paragraphText) {
-  let masked = paragraphText;
-  for (const abbreviation of NON_SENTENCE_ENDING_ABBREVIATIONS) {
-    const escaped = abbreviation.replace(/\./g, '\\.');
-    masked = masked.replace(new RegExp(`\\b${escaped}\\.`, 'g'), `${abbreviation}${ABBREVIATION_MASK_TOKEN}`);
-  }
-  return masked;
-}
-
-function unmaskAbbreviationPeriods(text) {
-  return text.replace(new RegExp(ABBREVIATION_MASK_TOKEN, 'g'), '.');
-}
-
-export function paragraphSplitsIntoDirectives(paragraphText) {
-  // A `.` `!` or `?` ends a sentence only when it is followed by whitespace
-  // and an uppercase letter, a backtick (next clause starts with `code`), or
-  // an opening parenthesis. This rule recognizes:
-  //   - file paths     "docs/DESIGN.md"        period + lowercase, no whitespace -> not a boundary
-  //   - dotted versions "v1.5", "2.0.0"        period + digit -> not a boundary
-  //   - domain literals "example.com"          period + lowercase -> not a boundary
-  //   - abbreviations  "e.g.", "i.e.", "etc."  pre-masked so their internal periods do not split
-  // Everything else is treated as sentence-final.
-  const masked = maskAbbreviationPeriods(paragraphText);
-  const SENTENCE_BOUNDARY = /([.!?])\s+(?=[A-Z`(])/g;
-  const sentences = [];
-  let cursor = 0;
-  for (const match of masked.matchAll(SENTENCE_BOUNDARY)) {
-    const sentenceEnd = match.index + match[1].length;
-    sentences.push(unmaskAbbreviationPeriods(masked.slice(cursor, sentenceEnd)).trim());
-    cursor = match.index + match[0].length;
-  }
-  const tail = unmaskAbbreviationPeriods(masked.slice(cursor)).trim();
-  if (tail.length > 0) {
-    sentences.push(tail);
-  }
-  return sentences.filter((sentence) => sentence.length > 0);
-}
-
-function renderBlockAsNumberedItem(block) {
-  if (block.kind === 'paragraph') {
-    return paragraphSplitsIntoDirectives(block.text);
-  }
-
-  // Each bullet becomes its own numbered directive. The format spec allows
-  // sub-bullets only as supporting detail under one parent directive, never
-  // as a way to compress an enumerative list into a single item. Keeping them
-  // as numbered items preserves citability (each becomes a sub-ID candidate
-  // during manual review) and matches the worked example in section 6.2.
-  return [...block.items];
-}
-
-function buildSectionBody(blocks) {
-  const numberedDirectives = [];
-  for (const block of blocks) {
-    const directives = renderBlockAsNumberedItem(block);
-    for (const directive of directives) {
-      numberedDirectives.push(directive);
-    }
-  }
-  return numberedDirectives;
-}
-
-/**
- * @param {{ prefix: string, domain: string, priority: string, scope: string, appliesTo: string[] }} prefixEntry
- * @param {ReturnType<typeof import('./parse-legacy.mjs').parseLegacyRuleFile>} parsedRuleFile
- * @returns {{ rendered: string, sectionAssignments: Array<{ sectionTitle: string, sectionId: string, itemCount: number }>, warnings: string[] }}
- */
-export function renderNewFormat(prefixEntry, parsedRuleFile) {
-  const warnings = [...parsedRuleFile.warnings];
-  const renderedParts = [];
-  renderedParts.push(renderFrontmatter(prefixEntry, parsedRuleFile));
-  renderedParts.push('\n');
-  renderedParts.push(`# ${parsedRuleFile.h1Title}\n\n`);
-  renderedParts.push(renderIntroParagraph(parsedRuleFile));
-
-  const sectionAssignments = [];
-  parsedRuleFile.sections.forEach((section, sectionIndex) => {
-    const sectionId = `${prefixEntry.prefix}-${String(sectionIndex + 1).padStart(3, '0')}`;
-    const numberedItems = buildSectionBody(section.blocks);
-    if (numberedItems.length > 12) {
-      warnings.push(
-        `Section "${section.title}" has ${numberedItems.length} numbered items. Format spec caps at 12; split into two sections during manual review.`,
-      );
-    }
-    if (numberedItems.length === 0) {
-      warnings.push(`Section "${section.title}" produced no numbered items. Manual review required.`);
-    }
-
-    renderedParts.push(`## ${sectionId}: ${section.title}\n\n`);
-    numberedItems.forEach((directive, itemIndex) => {
-      renderedParts.push(`${itemIndex + 1}. ${directive}\n`);
-    });
-    renderedParts.push('\n');
-
-    sectionAssignments.push({
-      sectionTitle: section.title,
-      sectionId,
-      itemCount: numberedItems.length,
-    });
-  });
-
-  return {
-    rendered: renderedParts.join('').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n',
-    sectionAssignments,
-    warnings,
-  };
-}