@ryuenn3123/agentic-senior-core 3.0.15 → 3.0.16

package/scripts/validate.mjs

@@ -16,7 +16,26 @@
 import { readdir, readFile, stat } from 'node:fs/promises';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { createHash } from 'node:crypto';
+import {
+  ALLOWED_SEVERITIES,
+  OVERRIDE_WARNING_WINDOW_DAYS,
+  REQUIRED_STACK_RESEARCH_ENGINE_SNIPPETS,
+} from './validate/config.mjs';
+import {
+  validateDependencyFreshnessAutomationCoverage,
+  validateDetectionTransparencyCoverage,
+  validateDeterministicBoundaryEnforcementCoverage,
+  validateDockerRuntimeAutomationCoverage,
+  validateHumanWritingGovernance,
+  validateInstructionAdapters,
+  validateSkillPurgeSurface,
+  validateStackResearchEngineCoverage,
+  validateTemplateFreeBootstrapCoverage,
+  validateTerminologyMapping,
+  validateUiDesignAutomationCoverage,
+  validateUniversalSopConsolidationCoverage,
+  validateUpgradeUiContractWarningCoverage,
+} from './validate/coverage-checks.mjs';
 
 const SCRIPT_FILE_PATH = fileURLToPath(import.meta.url);
 const ROOT_DIR = resolve(dirname(SCRIPT_FILE_PATH), '..');
@@ -28,393 +47,6 @@ const README_PATH = join(ROOT_DIR, 'README.md');
 const POLICY_FILE_PATH = join(ROOT_DIR, '.agent-context', 'policies', 'llm-judge-threshold.json');
 const OVERRIDE_FILE_PATH = join(ROOT_DIR, '.agent-override.md');
 const GENERATED_RULE_FILES = ['.cursorrules', '.windsurfrules'];
-const ALLOWED_SEVERITIES = new Set(['critical', 'high', 'medium', 'low']);
-const OVERRIDE_WARNING_WINDOW_DAYS = 30;
-const THIN_ADAPTER_PATHS = [
-  'AGENTS.md',
-  '.github/copilot-instructions.md',
-  '.gemini/instructions.md',
-];
-const FORMAL_ARTIFACT_PATHS = [
-  '.instructions.md',
-  'README.md',
-  'CHANGELOG.md',
-  'docs/deep_analysis_and_roadmap_backlog.md',
-  '.agent-context/rules/api-docs.md',
-  '.agent-context/review-checklists/pr-checklist.md',
-  '.agent-context/prompts/review-code.md',
-  'AGENTS.md',
-  '.github/copilot-instructions.md',
-  '.gemini/instructions.md',
-];
-const REQUIRED_HUMAN_WRITING_SNIPPETS = [
-  {
-    path: '.agent-context/rules/api-docs.md',
-    snippets: [
-      '## Human Writing Standard (Mandatory)',
-      'This applies to documentation, release notes, onboarding text, review summaries, and agent-facing explanations.',
-      'Style baseline findings are advisory by default and must not block endpoint-change commits that already include accurate docs/spec updates.',
-      'No emoji in formal artifacts.',
-    ],
-  },
-  {
-    path: '.agent-context/review-checklists/pr-checklist.md',
-    snippets: [
-      'Scope applied: This applies to documentation, release notes, onboarding text, review summaries, and agent-facing explanations',
-      'Style scope review is advisory and does not block merge when API docs are synced in the same commit and contract details are correct',
-      'No emoji in formal documentation or review summaries',
-      'Documentation uses plain English and avoids AI cliches',
-    ],
-  },
-  {
-    path: 'docs/deep_analysis_and_roadmap_backlog.md',
-    snippets: [
-      '## Part 6: Documentation and Explanation Standards (Mandatory)',
-      'This applies to documentation, release notes, onboarding text, review summaries, and agent-facing explanations.',
-      'No emoji in formal artifacts. This is mandatory.',
-    ],
-  },
-];
-const TERMINOLOGY_REFERENCE_PATHS = [
-  'README.md',
-  'docs/roadmap.md',
-];
-const REQUIRED_TERMINOLOGY_ROW_PATTERNS = [
-  {
-    label: 'Federated Governance -> Federated Rules Operations',
-    pattern: /\|\s*Federated Governance\s*\|\s*Federated Rules Operations\s*\|/u,
-  },
-  {
-    label: 'Governance Engine -> Rules Engine',
-    pattern: /\|\s*Governance Engine\s*\|\s*Rules Engine\s*\|/u,
-  },
-  {
-    label: 'Guardrails -> Quality Checks',
-    pattern: /\|\s*Guardrails\s*\|\s*Quality Checks\s*\|/u,
-  },
-];
-const REQUIRED_TERMINOLOGY_RULE_SNIPPET =
-  'Rule: on first mention in developer-facing docs, include canonical term in parentheses.';
-const TERMINOLOGY_REFERENCE_DOCUMENT_PATH = 'docs/terminology-mapping.md';
-const REQUIRED_DEVELOPER_FIRST_MENTION_PATTERNS = [
-  {
-    path: 'README.md',
-    label: 'Rules Engine first mention includes Governance Engine',
-    pattern: /Rules Engine\s*\(Governance Engine\)/u,
-  },
-  {
-    path: 'docs/deep-dive.md',
-    label: 'Dynamic Rules Engine first mention includes Governance Engine',
-    pattern: /Dynamic Rules Engine\s*\(Governance Engine\)/u,
-  },
-  {
-    path: 'docs/faq.md',
-    label: 'Quality Checks first mention includes Guardrails',
-    pattern: /Quality Checks\s*\(Guardrails\)/u,
-  },
-  {
-    path: '.agent-context/prompts/init-project.md',
-    label: 'Init prompt first mention includes Federated Governance baseline',
-    pattern: /rules operations context\s*\(Federated Governance baseline\)/iu,
-  },
-  {
-    path: 'lib/cli/commands/init.mjs',
-    label: 'Init command wording includes Federated Governance baseline',
-    pattern: /rules operations\s+(assets|pack)[^\n]*\(Federated Governance baseline\)/iu,
-  },
-  {
-    path: 'lib/cli/commands/upgrade.mjs',
-    label: 'Upgrade command wording includes Federated Governance baseline',
-    pattern: /rules operations upgrade assistant\s*\(Federated Governance baseline\)/iu,
-  },
-  {
-    path: 'lib/cli/utils.mjs',
-    label: 'CLI help wording includes quality checks and guardrails',
-    pattern: /quality checks\s*\(guardrails\)/iu,
-  },
-];
-const COMPLIANCE_TERMINOLOGY_BOUNDARY_PATHS = [
-  '.agent-context/review-checklists/pr-checklist.md',
-  '.agent-context/review-checklists/architecture-review.md',
-  'scripts/release-gate.mjs',
-  'scripts/forbidden-content-check.mjs',
-];
-const COMPLIANCE_ALIAS_TERMS = [
-  'Federated Rules Operations',
-];
-const REQUIRED_COMPLIANCE_CANONICAL_SNIPPETS = [
-  {
-    path: '.agent-context/review-checklists/pr-checklist.md',
-    snippet: '### 15. Universal SOP Consolidation',
-    label: 'PR checklist keeps consolidated Universal SOP section',
-  },
-];
-const REQUIRED_DETECTION_TRANSPARENCY_SNIPPETS = [
-  {
-    path: 'lib/cli/commands/init.mjs',
-    snippets: [
-      'Existing project detection transparency:',
-      'Use detected setup for this existing project?',
-      'detectionTransparency',
-    ],
-  },
-  {
-    path: 'lib/cli/commands/upgrade.mjs',
-    snippets: [
-      'Existing project detection transparency:',
-      'formatDetectionCandidates(projectDetection.rankedCandidates)',
-      'detectionTransparency',
-    ],
-  },
-  {
-    path: 'lib/cli/compiler.mjs',
-    snippets: [
-      'detectionTransparency = null',
-      'detectionTransparency: detectionTransparency || null',
-    ],
-  },
-];
-const REQUIRED_STACK_RESEARCH_ENGINE_SNIPPETS = [
-  {
-    path: 'lib/cli/architect.mjs',
-    snippets: [
-      'ARCHITECT_RESEARCH_SNAPSHOT_FILE_PATH',
-      'evidenceCitations',
-      'designGuidance',
-      'copiedExternalProse: false',
-      'realtimeGateEnabled',
-      'requestedMode: requestedResearchMode',
-    ],
-  },
-  {
-    path: 'lib/cli/commands/init.mjs',
-    snippets: [
-      '--architect-research-mode',
-      '--enable-realtime-research',
-      '--architect-realtime-signal-file',
-      'researchMode: initOptions.architectResearchMode',
-      'enableRealtimeResearch: initOptions.enableRealtimeResearch',
-    ],
-  },
-];
-const REQUIRED_UNIVERSAL_SOP_SNIPPETS = [
-  {
-    path: '.agent-context/rules/architecture.md',
-    snippets: [
-      '## Universal SOP Baseline (Mandatory)',
-      'Security and testing are non-negotiable baseline requirements.',
-      'If required project context docs are missing, stop implementation and bootstrap docs before writing application code.',
-    ],
-  },
-  {
-    path: '.agent-context/review-checklists/pr-checklist.md',
-    snippets: [
-      '### 15. Universal SOP Consolidation',
-      'Coding flow is blocked if `docs/architecture-decision-record.md` (or `docs/Architecture-Decision-Record.md`) is missing',
-      'UI implementation flow is blocked if `docs/DESIGN.md` or `docs/design-intent.json` is missing',
-    ],
-  },
-  {
-    path: '.agent-context/prompts/review-code.md',
-    snippets: [
-      'Enforce Universal SOP hard gate: block coding flow when required project docs are missing (`docs/architecture-decision-record.md`, and for UI scope `docs/DESIGN.md` plus `docs/design-intent.json`).',
-    ],
-  },
-  {
-    path: '.agent-context/prompts/refactor.md',
-    snippets: [
-      '6. Enforce Universal SOP hard gate: stop implementation if `docs/architecture-decision-record.md` is missing, and for UI scope stop if `docs/DESIGN.md` or `docs/design-intent.json` is missing.',
-    ],
-  },
-  {
-    path: 'lib/cli/compiler.mjs',
-    snippets: [
-      'Universal SOP hard block policy:',
-      'Hard block: do not write application code until docs/project-brief.md and docs/architecture-decision-record.md exist.',
-      'For UI scope: if docs/DESIGN.md or docs/design-intent.json is missing, execute bootstrap-design prompt before implementing UI surfaces.',
-    ],
-  },
-];
-const REQUIRED_TEMPLATE_FREE_BOOTSTRAP_SNIPPETS = [
-  {
-    path: 'lib/cli/project-scaffolder.mjs',
-    snippets: [
-      'resolveProjectDocTargets',
-      'Write project context docs from scratch (no template rendering, no placeholder boilerplate).',
-      'For any research-backed claim, include citation metadata (source + fetchedAt timestamp) from the Architect Engine Snapshot.',
-      "bootstrapMode: 'ai-synthesis'",
-    ],
-  },
-  {
-    path: 'lib/cli/commands/init.mjs',
-    snippets: [
-      'Project docs will be authored dynamically by your IDE assistant from these prompts.',
-      'bootstrap-project-context.md',
-      'Seed docs:',
-      'I prepared dynamic synthesis bootstrap prompts',
-    ],
-  },
-];
-const REQUIRED_UPGRADE_UI_CONTRACT_WARNING_SNIPPETS = [
-  {
-    path: 'lib/cli/commands/upgrade.mjs',
-    snippets: [
-      'UI/frontend scope was detected, but the dynamic design contract is incomplete:',
-      'docs/design-intent.json',
-      'Planned seed on apply: docs/design-intent.json',
-      'Upgrade synchronizes governance assets and can seed docs/design-intent.json, but it does not author project-specific docs/DESIGN.md automatically.',
-      'detectUiScopeSignals',
-      'seed-generated-during-upgrade',
-    ],
-  },
-];
-const REQUIRED_UI_DESIGN_AUTOMATION_SNIPPETS = [
-  {
-    path: '.instructions.md',
-    snippets: [
-      'UI Design Mode',
-      'bootstrap-design.md',
-      'frontend-architecture.md',
-      'do not eagerly load unrelated backend-only rules',
-    ],
-  },
-  {
-    path: '.agent-context/prompts/bootstrap-design.md',
-    snippets: [
-      'UI Design Mode is context-isolated by default:',
-      'Responsive Strategy and Cross-Viewport Adaptation Matrix',
-      '`colorTruth.format`',
-      '`crossViewportAdaptation.mutationRules.mobile/tablet/desktop`',
-      '`motionSystem`',
-      '`componentMorphology`',
-      'Do not reuse a color palette, component skin, or motion signature from prior chats, memories, or unrelated projects',
-      'If no approved reference system exists, synthesize the design from zero using current product context, constraints, and content only.',
-    ],
-  },
-  {
-    path: 'scripts/ui-design-judge.mjs',
-    snippets: [
-      'Advisory-first UI design contract judge.',
-      'Repo-internal workflow audit; no user-facing runtime modes.',
-      'Runs only in advisory mode for this repository workflow.',
-      'Do not reward generic SaaS defaults or popular template patterns.',
-      'UI design judge only evaluates changed UI surfaces.',
-    ],
-  },
-  {
-    path: 'lib/cli/project-scaffolder.mjs',
-    snippets: [
-      'colorTruth',
-      'crossViewportAdaptation',
-      'motionSystem',
-      'componentMorphology',
-      'requireViewportMutationRules',
-      'allowHexDerivatives',
-    ],
-  },
-  {
-    path: 'lib/cli/detector.mjs',
-    snippets: [
-      'hardcodedColorCount',
-      'propDrillingCandidateCount',
-      'arbitraryBreakpointCount',
-      'frontendEvidenceMetrics',
-    ],
-  },
-  {
-    path: 'lib/cli/compiler.mjs',
-    snippets: [
-      'LAYER 5: EXECUTION PROMPTS AND UI TRIGGERS',
-      'bootstrap-design.md -> ui, ux, layout, screen, tailwind, frontend, redesign',
-      'Keep UI-only requests context-isolated',
-    ],
-  },
-];
-const REQUIRED_DOCKER_RUNTIME_AUTOMATION_SNIPPETS = [
-  {
-    path: '.instructions.md',
-    snippets: [
-      'docker-runtime.md',
-      'For Docker or Compose work, load `docker-runtime.md` and verify the latest official Docker docs before authoring container assets.',
-    ],
-  },
-  {
-    path: '.agent-context/rules/docker-runtime.md',
-    snippets: [
-      'latest official Docker documentation first',
-      'Docker Compose Quickstart',
-      'Compose file reference',
-      'Dockerfile best practices',
-      'Prefer current `docker compose` workflows and `compose.yaml`.',
-      'Do not add the top-level Compose `version` field by default.',
-      'Prefer the latest stable compatible Docker base image',
-    ],
-  },
-  {
-    path: '.agent-context/prompts/init-project.md',
-    snippets: [
-      'If Docker or Compose is in scope, load [docker-runtime.md](../rules/docker-runtime.md) and verify the latest official Docker guidance before authoring container assets.',
-      'If containerization is selected, Docker assets must follow [docker-runtime.md](../rules/docker-runtime.md) and the latest official Docker docs instead of stale blog-era patterns.',
-    ],
-  },
-];
-const REQUIRED_DEPENDENCY_FRESHNESS_AUTOMATION_SNIPPETS = [
-  {
-    path: '.instructions.md',
-    snippets: [
-      'prefer the latest stable compatible dependency set and official setup flow',
-    ],
-  },
-  {
-    path: '.agent-context/rules/efficiency-vs-hype.md',
-    snippets: [
-      'Latest-Compatible-First Rule',
-      'latest stable compatible dependency version',
-      'official scaffolder or setup command',
-      'Only step down to an older dependency version after documenting',
-    ],
-  },
-  {
-    path: '.agent-context/prompts/init-project.md',
-    snippets: [
-      'latest stable compatible dependency set and official framework setup flow first',
-      'Prefer official framework setup commands or canonical starter flows',
-    ],
-  },
-];
-const FORBIDDEN_TEMPLATE_BOOTSTRAP_SNIPPETS = [
-  {
-    path: 'lib/cli/project-scaffolder.mjs',
-    snippets: [
-      '.tmpl',
-    ],
-  },
-];
-const REQUIRED_DETERMINISTIC_BOUNDARY_ENFORCEMENT_SNIPPETS = [
-  {
-    path: 'scripts/documentation-boundary-audit.mjs',
-    snippets: [
-      'reportVersion',
-      'violations',
-      'suggestedActions',
-      'diagnosticCode',
-      'autoDocsSyncScope',
-      'rolloutMetrics',
-      'precision',
-      'recall',
-    ],
-  },
-  {
-    path: 'scripts/release-gate.mjs',
-    snippets: [
-      'documentation-boundary-hard-rule',
-      'documentation-boundary-diagnostics-machine-readable',
-      'diagnostics.documentationBoundaryAudit',
-      'auto-docs-sync-scope-phase1',
-      'auto-docs-sync-rollout-metrics',
-    ],
-  },
-];
 
 const validationResult = {
   passed: 0,
@@ -926,347 +558,6 @@ async function validateDocumentationFlow() {
   }
 }
 
-async function validateTerminologyMapping() {
-  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('Compliance and audit artifacts must keep canonical enterprise 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);
-
-    if (!(await fileExists(absoluteReferencePath))) {
-      fail(`Missing terminology reference source: ${terminologyReferencePath}`);
-      continue;
-    }
-
-    const referenceContent = await readTextFile(absoluteReferencePath);
-
-    if (referenceContent.includes('Terminology Mapping (Final)')) {
-      pass(`${terminologyReferencePath} includes Terminology Mapping (Final)`);
-    } else {
-      fail(`${terminologyReferencePath} must include Terminology Mapping (Final)`);
-    }
-
-    for (const terminologyRowRule of REQUIRED_TERMINOLOGY_ROW_PATTERNS) {
-      if (terminologyRowRule.pattern.test(referenceContent)) {
-        pass(`${terminologyReferencePath} includes mapping row: ${terminologyRowRule.label}`);
-      } else {
-        fail(`${terminologyReferencePath} is missing mapping row: ${terminologyRowRule.label}`);
-      }
-    }
-
-    if (referenceContent.includes(REQUIRED_TERMINOLOGY_RULE_SNIPPET)) {
-      pass(`${terminologyReferencePath} includes first-mention canonical term rule`);
-    } 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) {
-    const absoluteFirstMentionPath = join(ROOT_DIR, firstMentionRule.path);
-
-    if (!(await fileExists(absoluteFirstMentionPath))) {
-      fail(`Missing developer-facing first-mention source: ${firstMentionRule.path}`);
-      continue;
-    }
-
-    const firstMentionContent = await readTextFile(absoluteFirstMentionPath);
-    if (firstMentionRule.pattern.test(firstMentionContent)) {
-      pass(`${firstMentionRule.path} keeps first-mention rule: ${firstMentionRule.label}`);
-    } else {
-      fail(`${firstMentionRule.path} must keep first-mention rule: ${firstMentionRule.label}`);
-    }
-  }
-
-  for (const compliancePath of COMPLIANCE_TERMINOLOGY_BOUNDARY_PATHS) {
-    const absoluteCompliancePath = join(ROOT_DIR, compliancePath);
-
-    if (!(await fileExists(absoluteCompliancePath))) {
-      fail(`Missing compliance/audit artifact for terminology boundary: ${compliancePath}`);
-      continue;
-    }
-
-    const complianceContent = await readTextFile(absoluteCompliancePath);
-    for (const aliasTerm of COMPLIANCE_ALIAS_TERMS) {
-      if (complianceContent.includes(aliasTerm)) {
-        fail(`${compliancePath} must not use developer-facing alias in compliance context: ${aliasTerm}`);
-      } else {
-        pass(`${compliancePath} keeps canonical terminology boundary for alias: ${aliasTerm}`);
-      }
-    }
-  }
-
-  for (const complianceRule of REQUIRED_COMPLIANCE_CANONICAL_SNIPPETS) {
-    const absoluteComplianceRulePath = join(ROOT_DIR, complianceRule.path);
-
-    if (!(await fileExists(absoluteComplianceRulePath))) {
-      fail(`Missing compliance canonical source: ${complianceRule.path}`);
-      continue;
-    }
-
-    const complianceRuleContent = await readTextFile(absoluteComplianceRulePath);
-    if (complianceRuleContent.includes(complianceRule.snippet)) {
-      pass(`${complianceRule.path} keeps canonical terminology rule: ${complianceRule.label}`);
-    } else {
-      fail(`${complianceRule.path} must keep canonical terminology rule: ${complianceRule.label}`);
-    }
-  }
-}
-
-async function validateDetectionTransparencyCoverage() {
-  console.log('\nChecking existing-project detection transparency coverage...');
-
-  for (const transparencyRule of REQUIRED_DETECTION_TRANSPARENCY_SNIPPETS) {
-    const absoluteTransparencyPath = join(ROOT_DIR, transparencyRule.path);
-
-    if (!(await fileExists(absoluteTransparencyPath))) {
-      fail(`Missing detection transparency source: ${transparencyRule.path}`);
-      continue;
-    }
-
-    const transparencyContent = await readTextFile(absoluteTransparencyPath);
-    for (const requiredSnippet of transparencyRule.snippets) {
-      if (transparencyContent.includes(requiredSnippet)) {
-        pass(`${transparencyRule.path} includes detection transparency snippet: ${requiredSnippet}`);
-      } else {
-        fail(`${transparencyRule.path} is missing detection transparency snippet: ${requiredSnippet}`);
-      }
-    }
-  }
-}
-
-async function validateStackResearchEngineCoverage() {
-  console.log('\nChecking stack research engine coverage...');
-
-  for (const coverageRule of REQUIRED_STACK_RESEARCH_ENGINE_SNIPPETS) {
-    const absoluteCoveragePath = join(ROOT_DIR, coverageRule.path);
-
-    if (!(await fileExists(absoluteCoveragePath))) {
-      fail(`Missing stack research source: ${coverageRule.path}`);
-      continue;
-    }
-
-    const coverageContent = await readTextFile(absoluteCoveragePath);
-    for (const requiredSnippet of coverageRule.snippets) {
-      if (coverageContent.includes(requiredSnippet)) {
-        pass(`${coverageRule.path} includes stack research snippet: ${requiredSnippet}`);
-      } else {
-        fail(`${coverageRule.path} is missing stack research snippet: ${requiredSnippet}`);
-      }
-    }
-  }
-}
-
-async function validateUniversalSopConsolidationCoverage() {
-  console.log('\nChecking Universal SOP consolidation coverage...');
-
-  for (const coverageRule of REQUIRED_UNIVERSAL_SOP_SNIPPETS) {
-    const absoluteCoveragePath = join(ROOT_DIR, coverageRule.path);
-
-    if (!(await fileExists(absoluteCoveragePath))) {
-      fail(`Missing Universal SOP source: ${coverageRule.path}`);
-      continue;
-    }
-
-    const coverageContent = await readTextFile(absoluteCoveragePath);
-    for (const requiredSnippet of coverageRule.snippets) {
-      if (coverageContent.includes(requiredSnippet)) {
-        pass(`${coverageRule.path} includes Universal SOP snippet: ${requiredSnippet}`);
-      } else {
-        fail(`${coverageRule.path} is missing Universal SOP snippet: ${requiredSnippet}`);
-      }
-    }
-  }
-}
-
-async function validateTemplateFreeBootstrapCoverage() {
-  console.log('\nChecking template-free dynamic bootstrap coverage...');
-
-  for (const coverageRule of REQUIRED_TEMPLATE_FREE_BOOTSTRAP_SNIPPETS) {
-    const absoluteCoveragePath = join(ROOT_DIR, coverageRule.path);
-
-    if (!(await fileExists(absoluteCoveragePath))) {
-      fail(`Missing template-free bootstrap source: ${coverageRule.path}`);
-      continue;
-    }
-
-    const coverageContent = await readTextFile(absoluteCoveragePath);
-    for (const requiredSnippet of coverageRule.snippets) {
-      if (coverageContent.includes(requiredSnippet)) {
-        pass(`${coverageRule.path} includes template-free bootstrap snippet: ${requiredSnippet}`);
-      } else {
-        fail(`${coverageRule.path} is missing template-free bootstrap snippet: ${requiredSnippet}`);
-      }
-    }
-  }
-
-  for (const forbiddenRule of FORBIDDEN_TEMPLATE_BOOTSTRAP_SNIPPETS) {
-    const absoluteForbiddenPath = join(ROOT_DIR, forbiddenRule.path);
-
-    if (!(await fileExists(absoluteForbiddenPath))) {
-      fail(`Missing template-free bootstrap source: ${forbiddenRule.path}`);
-      continue;
-    }
-
-    const forbiddenContent = await readTextFile(absoluteForbiddenPath);
-    for (const forbiddenSnippet of forbiddenRule.snippets) {
-      if (forbiddenContent.includes(forbiddenSnippet)) {
-        fail(`${forbiddenRule.path} must not include active template snippet: ${forbiddenSnippet}`);
-      } else {
-        pass(`${forbiddenRule.path} excludes active template snippet: ${forbiddenSnippet}`);
-      }
-    }
-  }
-}
-
-async function validateUpgradeUiContractWarningCoverage() {
-  console.log('\nChecking upgrade UI contract warning coverage...');
-
-  for (const coverageRule of REQUIRED_UPGRADE_UI_CONTRACT_WARNING_SNIPPETS) {
-    const absoluteCoveragePath = join(ROOT_DIR, coverageRule.path);
-
-    if (!(await fileExists(absoluteCoveragePath))) {
-      fail(`Missing upgrade UI contract warning source: ${coverageRule.path}`);
-      continue;
-    }
-
-    const coverageContent = await readTextFile(absoluteCoveragePath);
-    for (const requiredSnippet of coverageRule.snippets) {
-      if (coverageContent.includes(requiredSnippet)) {
-        pass(`${coverageRule.path} includes upgrade UI contract warning snippet: ${requiredSnippet}`);
-      } else {
-        fail(`${coverageRule.path} is missing upgrade UI contract warning snippet: ${requiredSnippet}`);
-      }
-    }
-  }
-}
-
-async function validateUiDesignAutomationCoverage() {
-  console.log('\nChecking UI design automation coverage...');
-
-  for (const coverageRule of REQUIRED_UI_DESIGN_AUTOMATION_SNIPPETS) {
-    const absoluteCoveragePath = join(ROOT_DIR, coverageRule.path);
-
-    if (!(await fileExists(absoluteCoveragePath))) {
-      fail(`Missing UI design automation source: ${coverageRule.path}`);
-      continue;
-    }
-
-    const coverageContent = await readTextFile(absoluteCoveragePath);
-    for (const requiredSnippet of coverageRule.snippets) {
-      if (coverageContent.includes(requiredSnippet)) {
-        pass(`${coverageRule.path} includes UI design automation snippet: ${requiredSnippet}`);
-      } else {
-        fail(`${coverageRule.path} is missing UI design automation snippet: ${requiredSnippet}`);
-      }
-    }
-  }
-}
-
-async function validateDockerRuntimeAutomationCoverage() {
-  console.log('\nChecking Docker runtime automation coverage...');
-
-  for (const coverageRule of REQUIRED_DOCKER_RUNTIME_AUTOMATION_SNIPPETS) {
-    const absoluteCoveragePath = join(ROOT_DIR, coverageRule.path);
-
-    if (!(await fileExists(absoluteCoveragePath))) {
-      fail(`Missing Docker runtime automation source: ${coverageRule.path}`);
-      continue;
-    }
-
-    const coverageContent = await readTextFile(absoluteCoveragePath);
-    for (const requiredSnippet of coverageRule.snippets) {
-      if (coverageContent.includes(requiredSnippet)) {
-        pass(`${coverageRule.path} includes Docker runtime automation snippet: ${requiredSnippet}`);
-      } else {
-        fail(`${coverageRule.path} is missing Docker runtime automation snippet: ${requiredSnippet}`);
-      }
-    }
-  }
-}
-
-async function validateDependencyFreshnessAutomationCoverage() {
-  console.log('\nChecking dependency freshness automation coverage...');
-
-  for (const coverageRule of REQUIRED_DEPENDENCY_FRESHNESS_AUTOMATION_SNIPPETS) {
-    const absoluteCoveragePath = join(ROOT_DIR, coverageRule.path);
-
-    if (!(await fileExists(absoluteCoveragePath))) {
-      fail(`Missing dependency freshness automation source: ${coverageRule.path}`);
-      continue;
-    }
-
-    const coverageContent = await readTextFile(absoluteCoveragePath);
-    for (const requiredSnippet of coverageRule.snippets) {
-      if (coverageContent.includes(requiredSnippet)) {
-        pass(`${coverageRule.path} includes dependency freshness automation snippet: ${requiredSnippet}`);
-      } else {
-        fail(`${coverageRule.path} is missing dependency freshness automation snippet: ${requiredSnippet}`);
-      }
-    }
-  }
-}
-
-async function validateDeterministicBoundaryEnforcementCoverage() {
-  console.log('\nChecking deterministic boundary enforcement coverage...');
-
-  for (const coverageRule of REQUIRED_DETERMINISTIC_BOUNDARY_ENFORCEMENT_SNIPPETS) {
-    const absoluteCoveragePath = join(ROOT_DIR, coverageRule.path);
-
-    if (!(await fileExists(absoluteCoveragePath))) {
-      fail(`Missing deterministic boundary source: ${coverageRule.path}`);
-      continue;
-    }
-
-    const coverageContent = await readTextFile(absoluteCoveragePath);
-    for (const requiredSnippet of coverageRule.snippets) {
-      if (coverageContent.includes(requiredSnippet)) {
-        pass(`${coverageRule.path} includes deterministic boundary snippet: ${requiredSnippet}`);
-      } else {
-        fail(`${coverageRule.path} is missing deterministic boundary snippet: ${requiredSnippet}`);
-      }
-    }
-  }
-}
-
 function isNormalizedMetricValue(value) {
   return Number.isFinite(Number(value)) && Number(value) >= 0 && Number(value) <= 1;
 }
@@ -1380,123 +671,22 @@ async function validateMcpConfiguration() {
   }
 }
 
-async function validateHumanWritingGovernance() {
-  console.log('\nChecking human writing governance...');
-
-  const disallowedEmojiPattern = /[\u2705\u274C\u26A0\u{1F4CC}\u{1F536}\u{1F4CE}\u{1F534}\u{1F7E0}\u{1F7E1}\u{1F7E2}]/u;
-
-  for (const formalArtifactPath of FORMAL_ARTIFACT_PATHS) {
-    const absoluteFormalArtifactPath = join(ROOT_DIR, formalArtifactPath);
-
-    if (!(await fileExists(absoluteFormalArtifactPath))) {
-      fail(`Missing formal artifact for writing governance: ${formalArtifactPath}`);
-      continue;
-    }
-
-    const formalArtifactContent = await readTextFile(absoluteFormalArtifactPath);
-
-    if (disallowedEmojiPattern.test(formalArtifactContent)) {
-      fail(`${formalArtifactPath} contains disallowed emoji symbols in formal text`);
-    } else {
-      pass(`${formalArtifactPath} has no disallowed emoji symbols`);
-    }
-  }
-
-  for (const snippetRule of REQUIRED_HUMAN_WRITING_SNIPPETS) {
-    const absoluteRulePath = join(ROOT_DIR, snippetRule.path);
-    if (!(await fileExists(absoluteRulePath))) {
-      fail(`Missing writing governance source: ${snippetRule.path}`);
-      continue;
-    }
-
-    const writingRuleContent = await readTextFile(absoluteRulePath);
-    for (const requiredSnippet of snippetRule.snippets) {
-      if (writingRuleContent.includes(requiredSnippet)) {
-        pass(`${snippetRule.path} includes writing governance snippet: ${requiredSnippet}`);
-      } else {
-        fail(`${snippetRule.path} is missing writing governance snippet: ${requiredSnippet}`);
-      }
-    }
-  }
-}
-
-async function validateInstructionAdapters() {
-  console.log('\nChecking instruction adapter consolidation...');
-
-  const canonicalInstructionContent = normalizeLineEndings(await readTextFile(CANONICAL_INSTRUCTION_PATH));
-  const canonicalSnapshotHash = createHash('sha256').update(canonicalInstructionContent).digest('hex');
-
-  for (const thinAdapterPath of THIN_ADAPTER_PATHS) {
-    const absoluteAdapterPath = join(ROOT_DIR, thinAdapterPath);
-
-    if (!(await fileExists(absoluteAdapterPath))) {
-      fail(`Missing thin adapter file: ${thinAdapterPath}`);
-      continue;
-    }
-
-    const thinAdapterContent = await readTextFile(absoluteAdapterPath);
-
-    if (
-      thinAdapterContent.includes('Adapter Mode: thin')
-      && thinAdapterContent.includes('Adapter Source: .instructions.md')
-    ) {
-      pass(`${thinAdapterPath} declares thin adapter metadata`);
-    } else {
-      fail(`${thinAdapterPath} must declare Adapter Mode: thin and Adapter Source: .instructions.md`);
-    }
-
-    const hashMatch = thinAdapterContent.match(/Canonical Snapshot SHA256:\s*([a-f0-9]{64})/);
-    if (!hashMatch) {
-      fail(`${thinAdapterPath} must declare Canonical Snapshot SHA256`);
-      continue;
-    }
-
-    if (hashMatch[1] === canonicalSnapshotHash) {
-      pass(`${thinAdapterPath} canonical hash matches .instructions.md`);
-    } else {
-      fail(`${thinAdapterPath} canonical hash drift detected (expected ${canonicalSnapshotHash})`);
-    }
-
-    const thinAdapterLineCount = thinAdapterContent.split(/\r?\n/u).length;
-    if (thinAdapterLineCount <= 80) {
-      pass(`${thinAdapterPath} remains thin (${thinAdapterLineCount} lines)`);
-    } else {
-      fail(`${thinAdapterPath} is too large for thin-adapter mode (${thinAdapterLineCount} lines)`);
-    }
-  }
-}
-
-async function validateSkillPurgeSurface() {
-  console.log('\nChecking skill and tier purge surface...');
-
-  const skillDirectoryPath = join(AGENT_CONTEXT_DIR, 'skills');
-  if (await fileExists(skillDirectoryPath)) {
-    fail('Skills directory must be removed: .agent-context/skills');
-  } else {
-    pass('Skills directory removed: .agent-context/skills');
-  }
-
-  const retiredFiles = [
-    join(ROOT_DIR, 'lib', 'cli', 'skill-selector.mjs'),
-    join(ROOT_DIR, 'scripts', 'skill-tier-policy.mjs'),
-    join(ROOT_DIR, 'scripts', 'trust-scorer.mjs'),
-  ];
-
-  for (const retiredFilePath of retiredFiles) {
-    const relativeRetiredPath = relative(ROOT_DIR, retiredFilePath).replace(/\\/g, '/');
-    if (await fileExists(retiredFilePath)) {
-      fail(`Retired file still present: ${relativeRetiredPath}`);
-    } else {
-      pass(`Retired file removed: ${relativeRetiredPath}`);
-    }
-  }
-}
-
 async function main() {
   console.log('===============================================');
   console.log('  Agentic-Senior-Core Repository Validator');
   console.log('===============================================');
 
+  const coverageValidationContext = {
+    AGENT_CONTEXT_DIR,
+    CANONICAL_INSTRUCTION_PATH,
+    ROOT_DIR,
+    fail,
+    fileExists,
+    normalizeLineEndings,
+    pass,
+    readTextFile,
+  };
+
   await validateRequiredFiles();
   await validateMarkdownFiles();
   await validateRuleFiles();
@@ -1508,21 +698,21 @@ async function main() {
   await validatePolicyFile();
   await validateVersionConsistency();
   await validateDocumentationFlow();
-  await validateTerminologyMapping();
-  await validateDetectionTransparencyCoverage();
-  await validateStackResearchEngineCoverage();
-  await validateUniversalSopConsolidationCoverage();
-  await validateTemplateFreeBootstrapCoverage();
-  await validateUpgradeUiContractWarningCoverage();
-  await validateUiDesignAutomationCoverage();
-  await validateDockerRuntimeAutomationCoverage();
-  await validateDependencyFreshnessAutomationCoverage();
-  await validateDeterministicBoundaryEnforcementCoverage();
+  await validateTerminologyMapping(coverageValidationContext);
+  await validateDetectionTransparencyCoverage(coverageValidationContext);
+  await validateStackResearchEngineCoverage(coverageValidationContext);
+  await validateUniversalSopConsolidationCoverage(coverageValidationContext);
+  await validateTemplateFreeBootstrapCoverage(coverageValidationContext);
+  await validateUpgradeUiContractWarningCoverage(coverageValidationContext);
+  await validateUiDesignAutomationCoverage(coverageValidationContext);
+  await validateDockerRuntimeAutomationCoverage(coverageValidationContext);
+  await validateDependencyFreshnessAutomationCoverage(coverageValidationContext);
+  await validateDeterministicBoundaryEnforcementCoverage(coverageValidationContext);
   await validateStackResearchSnapshotState();
   await validateMcpConfiguration();
-  await validateHumanWritingGovernance();
-  await validateInstructionAdapters();
-  await validateSkillPurgeSurface();
+  await validateHumanWritingGovernance(coverageValidationContext);
+  await validateInstructionAdapters(coverageValidationContext);
+  await validateSkillPurgeSurface(coverageValidationContext);
 
   console.log('\n===============================================');
   console.log('  RESULTS');