@ktpartners/dgs-platform 3.4.2 → 3.5.1

package/deliver-great-systems/bin/lib/jobs.cjs

@@ -30,7 +30,7 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
-const { output, error, getProjectRoot } = require('./core.cjs');
+const { output, error, getProjectRoot, phasesDir } = require('./core.cjs');
 const { getPlanningRoot } = require('./paths.cjs');
 const { requireGitIdentity, formatAuthorString } = require('./identity.cjs');
 const { extractFrontmatter, spliceFrontmatter, reconstructFrontmatter } = require('./frontmatter.cjs');
@@ -1128,7 +1128,9 @@ function analyzeMilestonePhases(cwd, version) {
   }
 
   const content = fs.readFileSync(roadmapPath, 'utf-8');
-  const phasesDir = path.join(projectRoot, 'phases');
+  let phasesAbs;
+  try { phasesAbs = path.join(cwd, phasesDir(cwd)); }
+  catch { phasesAbs = path.join(projectRoot, 'phases'); }
 
   // Find the milestone section: look for heading containing the version + "In Progress" or "SHIPPED"
   // Also match the milestone in the summary list to find its phase range
@@ -1155,52 +1157,77 @@ function analyzeMilestonePhases(cwd, version) {
     );
     const sectionMatch = content.match(sectionHeadingPattern);
     if (!sectionMatch) {
-      throw new Error(`Milestone ${version} not found in ROADMAP.md`);
-    }
+      // No ##-#### heading carries the version. Support the newer
+      // single-milestone ROADMAP format where the version appears ONLY in the
+      // `# Roadmap: ... (vX.Y)` title and a `**Milestone:** vX.Y` bold line.
+      // Gate the whole-roadmap phase scan behind a single-milestone check so a
+      // stray bold line on a multi-milestone roadmap does not mis-derive a range.
+      const boldMilestonePattern = new RegExp(
+        '^\\*\\*Milestone:\\*\\*\\s*' + escapedVersion + '\\b',
+        'im'
+      );
+      const versionHeadings = content.match(/^#{2,4}\s+.*v\d+\.\d+/gim) || [];
+      const isSingleMilestone = versionHeadings.length <= 1;
+      if (boldMilestonePattern.test(content) && isSingleMilestone) {
+        const fullPhasePattern = /Phase\s+(\d+)/gi;
+        const phaseNumbers = [];
+        let fpMatch;
+        while ((fpMatch = fullPhasePattern.exec(content)) !== null) {
+          phaseNumbers.push(parseInt(fpMatch[1], 10));
+        }
+        if (phaseNumbers.length === 0) {
+          throw new Error(`Milestone ${version} not found in ROADMAP.md`);
+        }
+        phaseStart = Math.min(...phaseNumbers);
+        phaseEnd = Math.max(...phaseNumbers);
+      } else {
+        throw new Error(`Milestone ${version} not found in ROADMAP.md`);
+      }
+    } else {
+      const headingLevel = sectionMatch[1].length;
+      const sectionStart = sectionMatch.index + sectionMatch[0].length;
 
-    const headingLevel = sectionMatch[1].length;
-    const sectionStart = sectionMatch.index + sectionMatch[0].length;
+      // Find the end of this section (next heading at same or higher level)
+      const endPattern = new RegExp(
+        `^#{2,${headingLevel}}\\s+`,
+        'im'
+      );
+      const restContent = content.slice(sectionStart);
+      const endMatch = restContent.match(endPattern);
+      const sectionContent = endMatch
+        ? restContent.slice(0, endMatch.index)
+        : restContent;
+
+      // Collect Phase N: headers within this section
+      const phaseHeaderPattern = /Phase\s+(\d+)\s*:/gi;
+      const phaseNumbers = [];
+      let phMatch;
+      while ((phMatch = phaseHeaderPattern.exec(sectionContent)) !== null) {
+        phaseNumbers.push(parseInt(phMatch[1], 10));
+      }
 
-    // Find the end of this section (next heading at same or higher level)
-    const endPattern = new RegExp(
-      `^#{2,${headingLevel}}\\s+`,
-      'im'
-    );
-    const restContent = content.slice(sectionStart);
-    const endMatch = restContent.match(endPattern);
-    const sectionContent = endMatch
-      ? restContent.slice(0, endMatch.index)
-      : restContent;
-
-    // Collect Phase N: headers within this section
-    const phaseHeaderPattern = /Phase\s+(\d+)\s*:/gi;
-    const phaseNumbers = [];
-    let phMatch;
-    while ((phMatch = phaseHeaderPattern.exec(sectionContent)) !== null) {
-      phaseNumbers.push(parseInt(phMatch[1], 10));
-    }
+      // If section-based search found nothing (common when ROADMAP has peer-level
+      // ## headings like ## v1.0, ## Overview, ## Phase Details), search the entire
+      // ROADMAP for Phase N: headings. For single-milestone ROADMAPs all phases
+      // belong to the milestone.
+      if (phaseNumbers.length === 0) {
+        const fullPhasePattern = new RegExp(
+          `Phase\\s+(\\d+)`,
+          'gi'
+        );
+        let fpMatch;
+        while ((fpMatch = fullPhasePattern.exec(content)) !== null) {
+          phaseNumbers.push(parseInt(fpMatch[1], 10));
+        }
+      }
 
-    // If section-based search found nothing (common when ROADMAP has peer-level
-    // ## headings like ## v1.0, ## Overview, ## Phase Details), search the entire
-    // ROADMAP for Phase N: headings. For single-milestone ROADMAPs all phases
-    // belong to the milestone.
-    if (phaseNumbers.length === 0) {
-      const fullPhasePattern = new RegExp(
-        `Phase\\s+(\\d+)`,
-        'gi'
-      );
-      let fpMatch;
-      while ((fpMatch = fullPhasePattern.exec(content)) !== null) {
-        phaseNumbers.push(parseInt(fpMatch[1], 10));
+      if (phaseNumbers.length === 0) {
+        throw new Error(`Milestone ${version} not found in ROADMAP.md`);
       }
-    }
 
-    if (phaseNumbers.length === 0) {
-      throw new Error(`Milestone ${version} not found in ROADMAP.md`);
+      phaseStart = Math.min(...phaseNumbers);
+      phaseEnd = Math.max(...phaseNumbers);
     }
-
-    phaseStart = Math.min(...phaseNumbers);
-    phaseEnd = Math.max(...phaseNumbers);
   }
 
   // Extract all phase detail sections: ### Phase N: Name
@@ -1222,12 +1249,12 @@ function analyzeMilestonePhases(cwd, version) {
     let diskStatus = 'no_directory';
 
     try {
-      const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
+      const entries = fs.readdirSync(phasesAbs, { withFileTypes: true });
       const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
       const dirMatch = dirs.find(d => d.startsWith(padded + '-') || d === padded);
 
       if (dirMatch) {
-        const phaseFiles = fs.readdirSync(path.join(phasesDir, dirMatch));
+        const phaseFiles = fs.readdirSync(path.join(phasesAbs, dirMatch));
         const planCount = phaseFiles.filter(f => f.endsWith('-PLAN.md') || f === 'PLAN.md').length;
         const summaryCount = phaseFiles.filter(f => f.endsWith('-SUMMARY.md') || f === 'SUMMARY.md').length;
         const hasContext = phaseFiles.some(f => f.endsWith('-CONTEXT.md') || f === 'CONTEXT.md');
@@ -1270,7 +1297,13 @@ function detectActiveMilestone(content) {
   if (match) return match[1];
   // Fallback: milestone list item with (in progress)
   const listMatch = content.match(/-\s+.*?(v\d+\.\d+).*?\((?:in\s+progress)\)/i);
-  return listMatch ? listMatch[1] : null;
+  if (listMatch) return listMatch[1];
+  // Final fallback: newer single-milestone format with a `**Milestone:** vX.Y`
+  // bold line. Runs LAST so legacy In-Progress heading/list signals win when
+  // present on multi-milestone roadmaps.
+  const boldMatch = content.match(/^\*\*Milestone:\*\*\s*(v\d+\.\d+)/im);
+  if (boldMatch) return boldMatch[1];
+  return null;
 }
 
 // ─── Milestone Job CLI Wrappers ─────────────────────────────────────────────
@@ -1517,37 +1550,63 @@ function cancelJob(cwd, version) {
 }
 
 /**
- * Validate jobs directory structure. Auto-create missing directories.
+ * Validate jobs directory structure (flat-first).
+ *
+ * Scans the flat `jobs/milestone-*.md` layout first. Legacy
+ * `pending/in-progress/completed` subdirs are an existence-gated optional
+ * fallback: they are counted + parse-validated when present, but are never
+ * created and their absence is not an issue. Only genuine parse failures
+ * flip `healthy` to false.
  *
  * @param {string} cwd - Working directory
  * @returns {{ healthy: boolean, directories: Array, job_count: number, issues?: Array }}
  */
 function healthCheck(cwd) {
   const jobsDir = path.join(getPlanningRoot(cwd), 'jobs');
-  const requiredDirs = ['pending', 'in-progress', 'completed'];
   const directories = [];
   const issues = [];
   let jobCount = 0;
 
-  for (const dirName of requiredDirs) {
-    const dirPath = path.join(jobsDir, dirName);
-    const exists = fs.existsSync(dirPath);
-    let created = false;
+  // An absent/empty jobs dir is healthy. Ensure it exists, but do not flag it.
+  let jobsCreated = false;
+  if (!fs.existsSync(jobsDir)) {
+    fs.mkdirSync(jobsDir, { recursive: true });
+    jobsCreated = true;
+  }
 
-    if (!exists) {
-      fs.mkdirSync(dirPath, { recursive: true });
-      created = true;
-      issues.push(`Missing directory auto-created: ${dirName}/`);
+  // Shared flat-job predicate (identical to findJobFile/listJobs). Excludes
+  // summary files (job-*-SUMMARY.md) since they do not start with 'milestone-'.
+  const isJobFile = f => f.startsWith('milestone-') && f.endsWith('.md');
+
+  // Flat-first scan: jobs/milestone-*.md
+  try {
+    const flatFiles = fs.readdirSync(jobsDir).filter(isJobFile);
+    jobCount += flatFiles.length;
+    for (const file of flatFiles) {
+      const filePath = path.join(jobsDir, file);
+      try {
+        parseJobFile(filePath);
+      } catch (err) {
+        issues.push(`Parse failure in ${file}: ${err.message}`);
+      }
     }
+  } catch {
+    // jobs dir unreadable; treat as empty.
+  }
 
-    directories.push({ name: dirName, exists: exists || created, created });
+  directories.push({ name: 'jobs', exists: true, created: jobsCreated });
+
+  // Legacy subdirs: existence-gated optional fallback. Never created.
+  const legacyDirs = ['pending', 'in-progress', 'completed'];
+  for (const dirName of legacyDirs) {
+    const dirPath = path.join(jobsDir, dirName);
+    if (!fs.existsSync(dirPath)) continue;
+
+    directories.push({ name: dirName, exists: true, created: false });
 
-    // Scan for job files
     try {
-      const files = fs.readdirSync(dirPath).filter(f => f.startsWith('milestone-') && f.endsWith('.md'));
+      const files = fs.readdirSync(dirPath).filter(isJobFile);
       jobCount += files.length;
-
-      // Validate each file
       for (const file of files) {
         const filePath = path.join(dirPath, file);
         try {
@@ -1557,7 +1616,7 @@ function healthCheck(cwd) {
         }
       }
     } catch {
-      // Directory just created, no files
+      // Subdir unreadable; skip.
     }
   }
 
@@ -1708,7 +1767,9 @@ function generateJobSummary(cwd, version) {
   try {
     const milestonePhases = analyzeMilestonePhases(cwd, normalizedVersion);
     const projectRoot = resolveProjectRoot(cwd);
-    const phasesDir = path.join(projectRoot, 'phases');
+    let phasesAbs;
+    try { phasesAbs = path.join(cwd, phasesDir(cwd)); }
+    catch { phasesAbs = path.join(projectRoot, 'phases'); }
 
     for (const phase of milestonePhases) {
       const phaseNum = phase.number;
@@ -1717,7 +1778,7 @@ function generateJobSummary(cwd, version) {
       // Find the phase directory on disk
       let phaseDir = null;
       try {
-        const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
+        const entries = fs.readdirSync(phasesAbs, { withFileTypes: true });
         const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
         phaseDir = dirs.find(d => d.startsWith(padded + '-') || d === padded);
       } catch {}
@@ -1725,7 +1786,7 @@ function generateJobSummary(cwd, version) {
       if (!phaseDir) continue;
 
       // Look for UAT file
-      const uatPath = path.join(phasesDir, phaseDir, `${padded}-UAT.md`);
+      const uatPath = path.join(phasesAbs, phaseDir, `${padded}-UAT.md`);
       let uatContent = null;
       try {
         uatContent = fs.readFileSync(uatPath, 'utf-8');
@@ -1921,7 +1982,9 @@ function rollbackJob(cwd, version) {
 
   // Identify executed phases from completed steps
   const projectRoot = resolveProjectRoot(cwd);
-  const phasesDir = path.join(projectRoot, 'phases');
+  let phasesAbs;
+  try { phasesAbs = path.join(cwd, phasesDir(cwd)); }
+  catch { phasesAbs = path.join(projectRoot, 'phases'); }
 
   for (const step of parsed.steps) {
     if (step.status === 'completed' && step.command === 'execute-phase') {
@@ -1932,12 +1995,12 @@ function rollbackJob(cwd, version) {
       const padded = phaseNum.replace(/^(\d+)/, (m) => m.padStart(2, '0'));
 
       try {
-        const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
+        const entries = fs.readdirSync(phasesAbs, { withFileTypes: true });
         const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
         const dirMatch = dirs.find(d => d.startsWith(padded + '-') || d === padded);
 
         if (dirMatch) {
-          const phaseDir = path.join(phasesDir, dirMatch);
+          const phaseDir = path.join(phasesAbs, dirMatch);
           const phaseFiles = fs.readdirSync(phaseDir);
           const summaryFiles = phaseFiles.filter(f => f.endsWith('-SUMMARY.md') || f === 'SUMMARY.md');
 
@@ -2111,6 +2174,8 @@ module.exports = {
   cmdJobsInsertPhaseGapFix,
   cmdJobsCreateMilestone,
   cmdJobsMilestonePreview,
+  analyzeMilestonePhases,
+  detectActiveMilestone,
   cmdJobsListJobs,
   cmdJobsCancelJob,
   cmdJobsRecordStartShas,

package/deliver-great-systems/bin/lib/jobs.test.cjs

@@ -18,6 +18,7 @@ const {
   parseJobFile, updateJobStep, moveJobFile,
   generateMilestoneSteps, buildJobFileContent,
   cmdJobsCreateMilestone, cmdJobsMilestonePreview,
+  analyzeMilestonePhases, detectActiveMilestone,
   findJobFile, updateJobHeader, insertJobSteps,
   buildGapFixSteps, insertGapFixSection,
   listJobs, cancelJob, recordStartShas, rollbackJob,
@@ -1379,6 +1380,105 @@ Plans:
     });
   });
 
+  // ─── Bold-line single-milestone format Tests ────────────────────────────
+
+  describe('bold-line single-milestone format', () => {
+    let fixture;
+
+    afterEach(() => {
+      if (fixture) fixture.cleanup();
+    });
+
+    const BOLD_LINE_ROADMAP = `# Roadmap: Tenant data-quality metrics in Admin UI (v30.1)
+
+**Milestone:** v30.1 — Tenant data-quality metrics in Admin UI
+
+## Overview
+
+Single-milestone roadmap. Version is only in the title and the bold line.
+
+### Phase 1: Metrics schema
+**Goal**: Define metrics tables
+Plans:
+- [ ] 01-01-PLAN.md
+
+### Phase 2: Admin UI surface
+**Goal**: Surface metrics in admin
+Plans:
+- [ ] 02-01-PLAN.md
+`;
+
+    const MULTI_MILESTONE_WITH_BOLD = `# Roadmap (v9.9)
+
+**Milestone:** v9.9 — stray bold line
+
+## v1.0 Foundation (SHIPPED)
+### Phase 1: Base
+### Phase 2: More base
+
+## v2.0 Next (In Progress)
+### Phase 3: New
+### Phase 4: Newer
+`;
+
+    it('detectActiveMilestone returns v30.1 from the bold line', () => {
+      assert.equal(detectActiveMilestone(BOLD_LINE_ROADMAP), 'v30.1');
+    });
+
+    it('analyzeMilestonePhases derives phases 1 and 2 from the bold-line roadmap', () => {
+      fixture = createFixture({
+        'ROADMAP.md': BOLD_LINE_ROADMAP,
+        'phases/01-metrics-schema/01-01-PLAN.md': '',
+        'phases/02-admin-ui/02-01-PLAN.md': '',
+      });
+
+      const phases = analyzeMilestonePhases(fixture.cwd, 'v30.1');
+      assert.equal(phases.length, 2);
+      assert.deepEqual(phases.map(p => p.number), ['1', '2']);
+    });
+
+    it('cmdJobsMilestonePreview succeeds with an explicit version', () => {
+      fixture = createFixture({
+        'ROADMAP.md': BOLD_LINE_ROADMAP,
+        'phases/01-metrics-schema/01-01-PLAN.md': '',
+        'phases/02-admin-ui/02-01-PLAN.md': '',
+      });
+
+      const result = cmdJobsMilestonePreview(fixture.cwd, 'v30.1', true, false);
+      assert.equal(result.preview, true);
+      assert.equal(result.version, 'v30.1');
+      assert.ok(result.step_count > 0, 'expected at least one step');
+    });
+
+    it('cmdJobsMilestonePreview auto-detects the bold-line version', () => {
+      fixture = createFixture({
+        'ROADMAP.md': BOLD_LINE_ROADMAP,
+        'phases/01-metrics-schema/01-01-PLAN.md': '',
+        'phases/02-admin-ui/02-01-PLAN.md': '',
+      });
+
+      const result = cmdJobsMilestonePreview(fixture.cwd, null, true, false);
+      assert.equal(result.version, 'v30.1');
+    });
+
+    it('analyzeMilestonePhases throws on a multi-milestone roadmap with a stray bold line', () => {
+      fixture = createFixture({
+        'ROADMAP.md': MULTI_MILESTONE_WITH_BOLD,
+        'phases/01-base/01-01-PLAN.md': '',
+        'phases/03-new/03-01-PLAN.md': '',
+      });
+
+      assert.throws(
+        () => analyzeMilestonePhases(fixture.cwd, 'v9.9'),
+        (err) => /v9\.9|not found/i.test(err.message)
+      );
+    });
+
+    it('detectActiveMilestone prefers the In-Progress heading over the bold line', () => {
+      assert.equal(detectActiveMilestone(MULTI_MILESTONE_WITH_BOLD), 'v2.0');
+    });
+  });
+
   // ─── findJobFile Tests ──────────────────────────────────────────────────
 
   describe('findJobFile', () => {
@@ -2124,8 +2224,24 @@ Plans:
     });
 
     it('returns not_in_progress when job is in pending/', () => {
+      // findJobFile's contract: frontmatter Status is authoritative, the
+      // legacy directory is advisory only ("Frontmatter wins"). A genuinely
+      // pending job therefore needs Status: pending in its frontmatter — using
+      // a status:in-progress fixture here would (correctly) be cancellable.
+      const PENDING_JOB = `# Milestone Job: v6.0
+
+**Version:** v6.0
+**Created:** 2026-03-02T10:00:00Z
+**Status:** pending
+**Check:** true
+
+## Steps
+
+- [ ] \`/dgs:plan-phase 41\`
+- [ ] \`/dgs:execute-phase 41\`
+`;
       fixture = createFixture({
-        'jobs/pending/milestone-v6.0.md': WELL_FORMED_JOB,
+        'jobs/pending/milestone-v6.0.md': PENDING_JOB,
       });
       const result = cancelJob(fixture.cwd, 'v6.0');
 
@@ -2166,18 +2282,46 @@ Plans:
       assert.equal(result.job_count, 0);
     });
 
-    it('returns healthy: false listing issues for missing directories, then auto-creates them', () => {
+    it('does not create legacy subdirs and stays healthy when they are absent', () => {
       fixture = createFixture({
         '': null,
       });
       const result = healthCheck(fixture.cwd);
 
-      // Should report missing directories but auto-create them
+      // An empty project (no legacy subdirs) is healthy with no jobs.
+      assert.equal(result.healthy, true);
+      assert.equal(result.job_count, 0);
       assert.ok(Array.isArray(result.directories));
-      // After auto-create, directories should exist
-      assert.ok(fs.existsSync(path.join(fixture.cwd, 'jobs', 'pending')));
-      assert.ok(fs.existsSync(path.join(fixture.cwd, 'jobs', 'in-progress')));
-      assert.ok(fs.existsSync(path.join(fixture.cwd, 'jobs', 'completed')));
+      // Legacy subdirs must NOT be auto-created.
+      assert.equal(fs.existsSync(path.join(fixture.cwd, 'jobs', 'pending')), false);
+      assert.equal(fs.existsSync(path.join(fixture.cwd, 'jobs', 'in-progress')), false);
+      assert.equal(fs.existsSync(path.join(fixture.cwd, 'jobs', 'completed')), false);
+    });
+
+    it('reports healthy: true for a flat jobs layout and does not create legacy subdirs', () => {
+      fixture = createFixture({
+        'jobs/milestone-v6.0.md': WELL_FORMED_JOB,
+      });
+      const result = healthCheck(fixture.cwd);
+
+      assert.equal(result.healthy, true);
+      assert.equal(result.job_count, 1);
+      assert.equal(result.issues.length, 0);
+      // No legacy subdirs created for a flat layout.
+      assert.equal(fs.existsSync(path.join(fixture.cwd, 'jobs', 'pending')), false);
+      assert.equal(fs.existsSync(path.join(fixture.cwd, 'jobs', 'in-progress')), false);
+      assert.equal(fs.existsSync(path.join(fixture.cwd, 'jobs', 'completed')), false);
+    });
+
+    it('excludes job-*-SUMMARY.md files from job_count in a flat layout', () => {
+      fixture = createFixture({
+        'jobs/milestone-v6.0.md': WELL_FORMED_JOB,
+        'jobs/job-v6.0-SUMMARY.md': '# Summary',
+      });
+      const result = healthCheck(fixture.cwd);
+
+      assert.equal(result.job_count, 1);
+      assert.equal(result.healthy, true);
     });
 
     it('validates each job file parses successfully; reports parse failures as issues', () => {
@@ -2530,14 +2674,14 @@ describe('jobs root-layout', () => {
     
   });
 
-  it('healthCheck creates jobs dirs at root layout', () => {
+  it('healthCheck does not create legacy subdirs at root layout', () => {
     fixture = createTempProject({ layout: 'root' });
     const result = healthCheck(fixture.cwd);
-    assert.ok(result.directories.length >= 3);
-    // Verify dirs were created at root
-    assert.ok(fs.existsSync(path.join(fixture.cwd, 'jobs', 'pending')));
-    assert.ok(fs.existsSync(path.join(fixture.cwd, 'jobs', 'in-progress')));
-    assert.ok(fs.existsSync(path.join(fixture.cwd, 'jobs', 'completed')));
+    assert.equal(result.healthy, true);
+    // Legacy subdirs must NOT be auto-created.
+    assert.equal(fs.existsSync(path.join(fixture.cwd, 'jobs', 'pending')), false);
+    assert.equal(fs.existsSync(path.join(fixture.cwd, 'jobs', 'in-progress')), false);
+    assert.equal(fs.existsSync(path.join(fixture.cwd, 'jobs', 'completed')), false);
   });
 
   it('listJobs works in root layout', () => {

package/deliver-great-systems/bin/lib/migration.test.cjs

@@ -423,6 +423,14 @@ describe('CLI: migrate command (MIG-08, OPT-02)', () => {
 
   beforeEach(() => {
     dir = makeGitDir();
+    // Real DGS repos gitignore config.local.json — the local half of the
+    // documented two-file config layout (config.json tracked / config.local.json
+    // gitignored). dgs-tools writes config.local.json on startup (e.g.
+    // { branching_migration_done: true }); without the .gitignore that real
+    // installs carry, that untracked write dirties the tree and trips migrate's
+    // (correct) clean-working-tree guard with exit 1. Mirror the real layout so
+    // the guard is exercised honestly rather than failing on a fixture artifact.
+    writeFile(dir, '.gitignore', 'config.local.json\n');
   });
 
   afterEach(() => {