@sun-asterisk/sungen 3.2.3 → 3.2.4

package/src/dashboard/types.ts

@@ -41,12 +41,14 @@ export interface AggregateSummary {
 export interface ScreenSnapshot {
   name: string;                        // "kudos" or "flow/checkout" — the screen DIRECTORY name
   isFlow: boolean;
+  platform?: 'web' | 'android' | 'ios' | 'mobile'; // 'mobile' = @platform:mobile screen (per-OS features below)
   featureName: string;                 // name of the primary (first) feature; kept for backwards compat
   featurePath?: string;                // entry-point path of the primary feature
   specLink?: string;                   // relative path to requirements/spec.md
   summary: ScreenSummaryStats;         // rollup across all features
   scenarios: ScenarioSnapshot[];       // flat list across all features (each carries its `featureBaseName`)
   features?: FeatureSnapshot[];        // present when a screen has 1+ .feature files; UI groups by this
+  executedPlatforms?: ('android' | 'ios')[]; // OSes that produced a result file this run (mobile only)
 }
 
 /**
@@ -67,7 +69,9 @@ export interface FeatureSnapshot {
   specLink?: string;                   // relative path to requirements/spec.md, when present
   summary: ScreenSummaryStats;         // BASE locale rollup — back-compat for non-locale consumers
   scenarios: ScenarioSnapshot[];       // BASE locale scenarios
-  locales?: LocaleSnapshot[];          // present when 2+ locales detected (base + at least one overlay)
+  locales?: LocaleSnapshot[];          // locale overlays WITHIN this entry (base + at least one overlay)
+  platform?: 'android' | 'ios';        // one OS run of a @platform:mobile feature (separate entry per OS)
+  executedPlatforms?: ('android' | 'ios')[]; // OSes that produced a result file this run (mobile only)
 }
 
 /**

package/src/exporters/csv-exporter.ts

@@ -16,7 +16,7 @@ import {
   splitVpAndName,
 } from './feature-parser';
 import { formatFeatureSteps, formatPrecondition, keepActor, stripActor } from './step-formatter';
-import { formatTestData } from './test-data-resolver';
+import { formatTestData, substituteTestDataVars } from './test-data-resolver';
 import {
   formatExecutedDate,
   formatNote,
@@ -83,10 +83,16 @@ export function buildTestCaseRows(input: BuildCsvInput): TestCaseRow[] {
     // Pre-condition is auth-only. Steps section = Background + @extend base
     // (entire) + own pre-Then. Expected = own's Then-onwards only.
     const precondition = formatPrecondition(authRole);
-    const localize = (text: string): string =>
-      input.selectorKeyMap
+    const localize = (text: string): string => {
+      // 1. resolve [Reference] selector keys → their label/value; 2. resolve {{var}} test-data
+      //    placeholders → concrete values, so Steps / Expected results show what QA actually verifies
+      //    (e.g. `text contains {{app_version}}` → `text contains Version 1.0.0`) instead of the raw
+      //    template. An unknown {{var}} is left literal.
+      const withKeys = input.selectorKeyMap
         ? substituteSelectorKeysInStep(text, input.selectorKeyMap, input.testData)
         : text;
+      return substituteTestDataVars(withKeys, input.testData);
+    };
     const formatStep = (s: { text: string; bucket: 'given' | 'when' | 'then' }) =>
       localize(s.bucket === 'given' ? keepActor(s.text) : stripActor(s.text));
     const stepLines    = m.resolvedSteps.map(formatStep).filter(Boolean);
@@ -127,7 +133,7 @@ export function buildTestCaseRows(input: BuildCsvInput): TestCaseRow[] {
     } else {
       testResult = statusToTestResult(result.status);
       executedDate = formatExecutedDate(result.startTime);
-      note = formatNote(result);
+      note = formatNote(result, expectedResults);
       environment = formatEnv(input.env.baseURL, input.featurePath, result.projectName || input.env.projectName);
       executor = input.env.executor;
     }

package/src/exporters/feature-parser.ts

@@ -90,6 +90,7 @@ export function parseFeatureMetadata(featureFilePath: string): FeatureMetadata {
       rawWhenSteps:  when,
       rawThenSteps:  then,
       orderedSteps:  ordered,
+      comments:      sc.comments,
     };
   });
 
@@ -132,9 +133,13 @@ export function extractPriority(tags: string[]): string {
 
 /**
  * Extract testcase type from scenario tags.
+ * Matches the bare `@manual` AND the reason-coded form `@manual:M1`..`@manual:M9`
+ * (the canonical way to tag manual scenarios). Without the `startsWith` check a
+ * `@manual:M1` scenario was misclassified as `Auto` → rendered "Not compiled"/"N/A"
+ * in the report instead of "Manual"/"Pending".
  */
 export function extractTestcaseType(tags: string[]): 'Auto' | 'Manual' {
-  return tags.includes('@manual') ? 'Manual' : 'Auto';
+  return tags.some((t) => t === '@manual' || t.startsWith('@manual:')) ? 'Manual' : 'Auto';
 }
 
 /**
@@ -153,7 +158,7 @@ export function extractAuthRole(tags: string[]): string | null {
  *   { vpId: "VP-UI-001", category1: "Modal displays all required fields" }
  */
 export function splitVpAndName(scenarioName: string): { vpId?: string; category1: string } {
-  const match = scenarioName.match(/^(VP-[A-Z]+-\d+[a-zA-Z]?)\s+(.+)$/);
+  const match = scenarioName.match(/^(VP-[A-Z][A-Z0-9]*-\d+[a-zA-Z]?)\s+(.+)$/);
   if (match) {
     return { vpId: match[1], category1: match[2] };
   }

package/src/exporters/json-exporter.ts

@@ -111,9 +111,17 @@ export function buildScreenSnapshot(input: BuildScreenSnapshotInput): ScreenSnap
         status = statusToTestResult(result.status) as ScenarioSnapshot['status'];
         executedDate = formatExecutedDate(result.startTime);
         if (result.error) {
-          // Strip a leading "Error:" so consumers (dashboard / CSV `Note`)
-          // can prepend their own label without ending up with `Error: Error:`.
-          errorMessage = String(result.error).split('\n')[0].trim().replace(/^Error:\s*/i, '');
+          // Keep the FULL assertion message on one line. Do NOT use split('\n')[0]: a WDIO
+          // selector value can itself contain a newline (a Flutter composite accessibility-id
+          // like `~Share with Friends\nSpread the word`), which would truncate the message
+          // mid-selector. Drop the stack trace (frames start with "at "), collapse the remaining
+          // newlines (incl. the Expected/Received lines) to spaces, and strip a leading "Error:"
+          // so consumers (dashboard / CSV `Note`) can prepend their own label.
+          errorMessage = String(result.error)
+            .split(/\n\s*at\s/)[0]
+            .replace(/\s*\n\s*/g, ' ')
+            .trim()
+            .replace(/^Error:\s*/i, '');
         }
         if (result.tracePath) tracePath = result.tracePath;
         testEnvironment = formatTestEnvironment(input.env.baseURL, input.featurePath, result.projectName || input.env.projectName);

package/src/exporters/playwright-report-parser.ts

@@ -192,22 +192,61 @@ export function formatExecutedDate(startTime: string | undefined): string {
   return `${dd}/${mm}/${yyyy}`;
 }
 
+const NOTE_FIELD_MAX = 300;
+const clip = (s: string): string => {
+  const t = s.replace(/\s*\n\s*/g, ' ').trim();
+  return t.length > NOTE_FIELD_MAX ? t.slice(0, NOTE_FIELD_MAX - 1) + '…' : t;
+};
+
+/**
+ * Split an assertion failure message into its Expected + Received values, so QA can compare.
+ * Both frameworks embed them in the error message: Playwright — `Expected string: "…"` /
+ * `Received string: "…"` (also `Expected pattern/substring/value`, `Received value`); expect-
+ * webdriverio — `Expected: …` / `Received: …`. `(.+)` (no /s flag) captures to end-of-line, so a
+ * multi-line stack after the value is not swallowed. Undefined when the message isn't an assertion
+ * (e.g. element-not-found / timeout) — then there is no runtime Expected to show.
+ */
+export function parseExpectedReceived(raw: string): { expected?: string; received?: string } {
+  const grab = (re: RegExp): string | undefined => { const m = raw.match(re); return m ? clip(m[1]) : undefined; };
+  return {
+    expected: grab(/\bExpected(?:\s+[\w-]+)?:\s*(.+)/i),
+    received: grab(/\bReceived(?:\s+[\w-]+)?:\s*(.+)/i),
+  };
+}
+
 /**
- * Format error message for Note column. Truncate long stacks, include trace path.
+ * Format the Note column for a FAILED test case (returns '' for any non-failed status — so only
+ * `Test Result = Failed` rows get a Note). Emits the two fields QA compares:
+ *   • Expected result: the asserted value parsed from the error, or — when the failure isn't an
+ *     assertion (timeout / element-not-found, which carry no Expected/Received) — the scenario's
+ *     expected (`expectedFallback`, i.e. the "Expected results" column / Then steps), so QA always
+ *     sees what SHOULD have happened next to the actual.
+ *   • Actual result: the Received value, or the raw error.
+ * Plus the trace path.
  */
-export function formatNote(result: PlaywrightResult | undefined): string {
+export function formatNote(result: PlaywrightResult | undefined, expectedFallback = ''): string {
   if (!result) return '';
   if (result.status !== 'failed' && result.status !== 'timedOut') return '';
-  // Some Playwright error messages already start with `Error:` — strip it
-  // so we don't end up rendering `Error: Error: …` once we prepend the label.
-  const firstLine = (result.error || '').split('\n')[0].trim().replace(/^Error:\s*/i, '');
-  const truncated = firstLine.length > 200 ? firstLine.substring(0, 197) + '…' : firstLine;
+  // Full assertion message with stack frames dropped (frames start with "at ") + a leading `Error:`
+  // stripped. Keep newlines here so parseExpectedReceived can delimit the Expected/Received lines.
+  const raw = (result.error || '').split(/\n\s*at\s/)[0].replace(/^Error:\s*/i, '').trim();
+  const { expected, received } = parseExpectedReceived(raw);
+  const actual = received || clip(raw); // received value, else the raw error
+
+  // Newline-separated bullets so each field lands on its own row when the cell wraps — matches the
+  // Test Data column's `• key: value` formatting. Excel/CSV honour `\n` inside quoted cells; the
+  // dashboard modal renders with whitespace-pre-wrap.
   const parts: string[] = [];
-  if (truncated)        parts.push(`• Error: ${truncated}`);
+  // Expected result: a parsed assertion value stays inline; the scenario expected (Then steps) can be
+  // several numbered criteria — put each on its own indented line so the cell reads as a list.
+  if (expected) {
+    parts.push(`• Expected result: ${expected}`);
+  } else {
+    const lines = expectedFallback.split(/\r?\n/).map((l) => clip(l)).filter(Boolean);
+    if (lines.length === 1) parts.push(`• Expected result: ${lines[0]}`);
+    else if (lines.length > 1) parts.push(`• Expected result:\n${lines.map((l) => `   ${l}`).join('\n')}`);
+  }
+  if (actual)           parts.push(`• Actual result: ${actual}`);
   if (result.tracePath) parts.push(`• Trace: ${result.tracePath}`);
-  // Newline-separated bullets so each field lands on its own row when the
-  // cell wraps — matches the Test Data column's `• key: value` formatting.
-  // Excel/CSV honour `\n` inside quoted cells; the dashboard modal already
-  // renders this with whitespace-pre-wrap.
   return parts.join('\n');
 }

package/src/exporters/scenario-merger.ts

@@ -9,7 +9,43 @@
  */
 
 import { FeatureMetadata, OrderedStep, ScenarioMetadata, SpecFileData, SpecTest } from './types';
-import { isStepsBaseScenario, isSampleScaffoldScenario } from './feature-parser';
+import { isStepsBaseScenario, isSampleScaffoldScenario, extractTestcaseType } from './feature-parser';
+
+/**
+ * Parse a @manual scenario's `# Tester verifies:` comment block into procedure vs
+ * expected. Each item is a numbered line, optionally prefixed with a label:
+ *   1. Setup: …   2. Action: …        → procedure (Steps column)
+ *   3. Observable: …  4. Oracle: …    → expected (Expected Results column)
+ * A label matching observ|oracle|expect|result|then|assert → Expected; anything else
+ * (Setup/Action/Precondition/unlabelled) → Steps. A non-numbered line following a
+ * numbered item is a continuation (e.g. a wrapped URL) and is appended to it. Pre-amble
+ * lines (the `MANUAL:` rationale, the `Tester verifies:` header, separators) are ignored.
+ */
+function parseManualComments(comments: string[]): { steps: OrderedStep[]; expected: OrderedStep[] } {
+  const steps: OrderedStep[] = [];
+  const expected: OrderedStep[] = [];
+  let last: OrderedStep | null = null;
+  const isExpectedLabel = (l: string) => /observ|oracle|expect|result|then|assert/i.test(l);
+  for (const raw of comments) {
+    const line = raw.trim();
+    if (!line) continue;
+    // Section divider — all divider chars (`-----`) OR a titled rule (`--- Foo ---`).
+    // A run of 2+ leading divider chars is never a step or a continuation.
+    if (/^[-=*_]{2,}/.test(line)) { last = null; continue; }
+    const m = line.match(/^\d+[.)]\s*(?:([A-Za-z][A-Za-z /]*?):\s*)?(.+)$/);
+    if (m) {
+      const label = (m[1] || '').trim();
+      const text = label ? `${label}: ${m[2].trim()}` : m[2].trim();
+      const step: OrderedStep = { text, bucket: isExpectedLabel(label) ? 'then' : 'when' };
+      (step.bucket === 'then' ? expected : steps).push(step);
+      last = step;
+    } else if (last) {
+      last.text += ' ' + line; // continuation of the previous numbered item
+    }
+    // else: pre-amble before any numbered item (rationale / header) → skip
+  }
+  return { steps, expected };
+}
 
 export interface MergedScenario {
   /** Scenario metadata from .feature */
@@ -76,6 +112,15 @@ export function mergeFeatureAndSpec(
     const ownPreThen = firstThenIdx >= 0 ? ownOrdered.slice(0, firstThenIdx) : ownOrdered;
     const ownPostThen = firstThenIdx >= 0 ? ownOrdered.slice(firstThenIdx) : [];
 
+    // A @manual scenario carries no Gherkin steps — its tester procedure lives in the
+    // `# Tester verifies:` comment block. Parse it into Steps (Setup/Action) + Expected
+    // (Observable/Oracle) so the delivery report shows the real manual procedure, not
+    // just the Background nav. No-op for automated scenarios (comments stay notes).
+    const manualParsed =
+      extractTestcaseType(scenario.tags) === 'Manual' && scenario.comments?.length
+        ? parseManualComments(scenario.comments)
+        : { steps: [] as OrderedStep[], expected: [] as OrderedStep[] };
+
     result.push({
       feature: scenario,
       spec: specTest,
@@ -98,8 +143,9 @@ export function mergeFeatureAndSpec(
         ...feature.backgroundOrderedSteps,
         ...(base?.orderedSteps ?? []),
         ...ownPreThen,
+        ...manualParsed.steps,
       ],
-      resolvedExpected: ownPostThen,
+      resolvedExpected: [...ownPostThen, ...manualParsed.expected],
     });
   }
 
@@ -116,7 +162,7 @@ function findMatchingSpecTest(scenario: ScenarioMetadata, tests: SpecTest[]): Sp
   if (exact) return exact;
 
   // Fallback: match by VP-ID prefix (ignore trailing text differences)
-  const vpMatch = scenario.name.match(/^(VP-[A-Z]+-\d+[a-zA-Z]?)/);
+  const vpMatch = scenario.name.match(/^(VP-[A-Z][A-Z0-9]*-\d+[a-zA-Z]?)/);
   if (vpMatch) {
     const vpId = vpMatch[1];
     const byVp = tests.find((t) => t.vpId === vpId);

package/src/exporters/spec-parser.ts

@@ -146,7 +146,7 @@ function classifyBlock(block: CodeBlock): 'precondition' | 'step' | 'expectation
  * Try to extract VP ID (e.g., VP-UI-001) from the start of a scenario title.
  */
 function extractVpId(title: string): string | undefined {
-  const match = title.match(/^(VP-[A-Z]+-\d+[a-zA-Z]?)\b/);
+  const match = title.match(/^(VP-[A-Z][A-Z0-9]*-\d+[a-zA-Z]?)\b/);
   return match ? match[1] : undefined;
 }
 

package/src/exporters/test-data-resolver.ts

@@ -133,6 +133,19 @@ function truncate(s: string, max: number): string {
   return s.substring(0, max - 1) + '…';
 }
 
+/**
+ * Resolve `{{var}}` test-data placeholders in a step / expected-result line to their concrete values,
+ * so the delivery report shows what QA actually verifies (e.g. `text contains {{app_version}}` →
+ * `text contains Version 1.0.0`). Dotted keys (`{{a.b}}`) are supported. A key absent from the
+ * test-data map (or resolving to empty) is left as the literal `{{var}}` — never blanked.
+ */
+export function substituteTestDataVars(text: string, testData: Record<string, string>): string {
+  return text.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (m, key: string) => {
+    const v = testData[key];
+    return v === undefined || v === null || v === '' ? m : String(v);
+  });
+}
+
 /**
  * Resolve the test-data file path for a given screen.
  */

package/src/exporters/types.ts

@@ -88,6 +88,12 @@ export interface ScenarioMetadata {
    * Use this when ordering matters — e.g. mid-scenario `Given` after `When`.
    */
   orderedSteps: OrderedStep[];
+  /**
+   * Comment lines inside the scenario body (leading `# ` stripped). For a @manual
+   * scenario the tester procedure lives here (as `# Tester verifies:` comments), not
+   * as Gherkin steps — the merger parses these into Steps/Expected for the report.
+   */
+  comments?: string[];
 }
 
 /**

package/src/exporters/xlsx-exporter.ts

@@ -30,6 +30,15 @@ const META_FILL = 'FFDCE6F1'; // soft blue for meta rows
 const CATEGORY_FILL = 'FFD9D2E9'; // same lavender for group dividers (Accessing / GUI / Function)
 const BORDER_COLOR = 'FFBFBFBF';
 
+// Shared masthead + table styling (BM-2-901-13 header band, summary band, Overview table).
+const TIMES = 'Times New Roman';
+const ARIAL_FONT = 'Arial';
+const BLACK = { argb: 'FF000000' };
+const WHITE = { argb: 'FFFFFFFF' };
+const LAVENDER = { argb: 'FFD9D2E9' };
+const thinBlack = { style: 'thin' as const, color: BLACK };
+const allBordersBlack = { top: thinBlack, left: thinBlack, bottom: thinBlack, right: thinBlack };
+
 type AnyCell = ExcelJS.Cell;
 type AnyRow = ExcelJS.Row;
 
@@ -96,6 +105,9 @@ export function renderXlsxMultiSheet(sheets: LocaleSheet[]): ExcelJS.Workbook {
   const wb = new ExcelJS.Workbook();
   wb.creator = 'sungen delivery';
   wb.created = new Date();
+  // Overview first — a per-sheet roll-up (Passed/Failed/Pending/N/A/Remain/Total)
+  // plus a grand-total row, so QA sees the whole picture before the detail sheets.
+  addOverviewSheet(wb, sheets);
   for (const s of sheets) {
     addTestcaseSheet(wb, s.sheetName, s.summary, s.rows, s.specLink);
   }
@@ -103,57 +115,23 @@ export function renderXlsxMultiSheet(sheets: LocaleSheet[]): ExcelJS.Workbook {
 }
 
 /**
- * Append one BM-2-901-13 testcase sheet to the given workbook. Sheet content
- * (layout, summary band, data rows, auto-filter, protection) is identical to
- * the single-sheet `renderXlsx` output — only the sheet name differs.
+ * Render the shared BM-2-901-13 masthead (rows 1-4) onto a worksheet:
+ * Sun* logo (A1:C3), TESTCASE title (D1:F3), No/Version/Issue-Date block
+ * (G1:H3), company line (A4:F4), ISO line (G4:H4). Every sheet in a delivery
+ * workbook — Overview, Auto, Manual — carries this same header band.
  */
-function addTestcaseSheet(
+function renderReportHeaderBand(
   wb: ExcelJS.Workbook,
-  sheetName: string,
-  summary: ScreenSummary,
-  rows: TestCaseRow[],
-  specLink: string,
+  ws: ExcelJS.Worksheet,
+  titleLabel: string,
 ): void {
-  const ws = wb.addWorksheet(sheetName, {
-    views: [{ state: 'frozen', ySplit: 0, xSplit: 0 }],
-  });
-
   const issueDate = (() => {
     const d = new Date();
     return `${String(d.getDate()).padStart(2, '0')}/${String(d.getMonth() + 1).padStart(2, '0')}/${d.getFullYear()}`;
   })();
 
-  // -- Column widths matching template_report.xlsx (Sample sheet) --
-  ws.columns = [
-    { width: 20 },    // A — TC ID (wider to fit long flow IDs like FLOW-KUDO-…)
-    { width: 12.5 },  // B — Screen/Function
-    { width: 15.38 }, // C — Big item
-    { width: 16.25 }, // D — Medium item
-    { width: 17 },    // E — Test Object
-    { width: 25.5 },  // F — Pre-condition
-    { width: 24.88 }, // G — Test Data
-    { width: 24.88 }, // H — Steps
-    { width: 41 },    // I — Expected results
-    { width: 12 },    // J — Priority
-    { width: 13.5 },  // K — Testcase type
-    { width: 15.88 }, // L — Test Result
-    { width: 13.5 },  // M — Executed Date
-    { width: 16.5 },  // N — Test Executor
-    { width: 23 },    // O — Test Environment
-    { width: 29 },    // P — Note
-  ];
-
-  // -- Top metadata band (rows 1-4) — 1:1 with template_report.xlsx --
-  const TIMES = 'Times New Roman';
-  const ARIAL_FONT = 'Arial';
-  const BLACK = { argb: 'FF000000' };
-  const WHITE = { argb: 'FFFFFFFF' };
-  const LAVENDER = { argb: 'FFD9D2E9' };
-  const thinBlack = { style: 'thin' as const, color: BLACK };
-  const allBordersBlack = { top: thinBlack, left: thinBlack, bottom: thinBlack, right: thinBlack };
-
-  // Ensure rows 1..8 exist before merging.
-  for (let r = 1; r <= 8; r++) ws.getRow(r);
+  // Ensure rows 1..4 exist before merging.
+  for (let r = 1; r <= 4; r++) ws.getRow(r);
 
   ws.mergeCells('A1:C3');
   ws.mergeCells('D1:F3');
@@ -174,10 +152,6 @@ function addTestcaseSheet(
       extension: 'png',
     });
     // Centre a fixed-size 90×51 logo inside A1:C3 using absolute EMU offsets.
-    // Col widths (A=20, B=12.5, C=15.38) → pixels via Excel's `w*7+5` rule:
-    //   A=145, B=92.5, C=112.66  ⇒  A1:C3 ≈ 350 px wide.
-    // Left padding for a 90-px image = (350−90)/2 ≈ 130 px = 1,237,500 EMU.
-    // 3 default rows × 20 px = 60 px; top padding ≈ 4.5 px ≈ 42,862 EMU.
     ws.addImage(imageId, {
       tl: { nativeCol: 0, nativeColOff: 1237500, nativeRow: 0, nativeRowOff: 42862 } as unknown as ExcelJS.Anchor,
       ext: { width: 90, height: 51 },
@@ -186,7 +160,6 @@ function addTestcaseSheet(
   } catch { /* logo is decorative — never block export */ }
 
   // D1 (TESTCASE title)
-  const titleLabel = `${summary.screen.toUpperCase()} TESTCASE`;
   const d1 = ws.getCell('D1');
   d1.value = titleLabel;
   d1.font = { bold: true, size: 18, name: TIMES };
@@ -227,6 +200,134 @@ function addTestcaseSheet(
   g4.font = { bold: true, size: 10, name: TIMES };
   g4.alignment = { horizontal: 'right', vertical: 'middle', wrapText: true };
   g4.border = allBordersBlack;
+}
+
+// ---------------------------------------------------------------------------
+// Overview sheet — the first tab in every multi-sheet delivery workbook.
+// Rolls up each testcase sheet's Passed/Failed/Pending/N/A/Remain/Total into
+// one summary table (+ a grand-total row) under the shared masthead. Reads
+// only each sheet's summary — never touches the detail sheets themselves.
+// ---------------------------------------------------------------------------
+
+/** Column headers for the Overview roll-up table (cols A..H). */
+const OVERVIEW_HEADERS = ['#', 'Sheet name', 'Passed', 'Failed', 'Pending', 'N/A', 'Remain', 'Total'];
+
+/**
+ * Prepend an "Overview" worksheet summarizing every sheet in `sheets`.
+ *
+ * `Remain = Total − Passed − N/A` (i.e. Failed + Pending) so the number
+ * reconciles with the "Remaining" cell in each detail sheet's summary band.
+ */
+function addOverviewSheet(wb: ExcelJS.Workbook, sheets: LocaleSheet[]): void {
+  const ws = wb.addWorksheet('Overview');
+
+  // Table starts at column B row 7 (A is a thin left margin). Widths keep the
+  // A..H masthead readable AND the count columns tidy.
+  ws.columns = [
+    { width: 4 },   // A — left margin
+    { width: 6 },   // B — #
+    { width: 26 },  // C — Sheet name
+    { width: 13 },  // D — Passed
+    { width: 13 },  // E — Failed
+    { width: 13 },  // F — Pending
+    { width: 13 },  // G — N/A
+    { width: 13 },  // H — Remain
+    { width: 13 },  // I — Total
+  ];
+
+  const titleScreen = sheets[0]?.summary.screen ?? '';
+  renderReportHeaderBand(wb, ws, `${titleScreen.toUpperCase()} TESTCASE`);
+
+  // Roll-up table: header on row 7, first column B (index 2).
+  const HEADER_ROW = 7;
+  const FIRST_COL = 2; // column B
+  const headerRow = ws.getRow(HEADER_ROW);
+  headerRow.height = 20;
+  OVERVIEW_HEADERS.forEach((label, i) => {
+    const c = headerRow.getCell(FIRST_COL + i);
+    c.value = label;
+    c.font = { bold: true, size: 10, color: BLACK, name: ARIAL_FONT };
+    c.fill = { type: 'pattern', pattern: 'solid', fgColor: LAVENDER };
+    c.alignment = { horizontal: 'center', vertical: 'middle', wrapText: true };
+    c.border = allBordersBlack;
+  });
+
+  const totals = { passed: 0, failed: 0, pending: 0, na: 0, remain: 0, total: 0 };
+
+  const writeDataRow = (rowIdx: number, values: ExcelJS.CellValue[], isTotal: boolean): void => {
+    const row = ws.getRow(rowIdx);
+    values.forEach((v, i) => {
+      const c = row.getCell(FIRST_COL + i);
+      c.value = v;
+      c.font = { bold: isTotal, size: 10, color: BLACK, name: ARIAL_FONT };
+      // The '#' + 'Sheet name' columns read left; the counts centre like the band.
+      c.alignment = { horizontal: i <= 1 ? 'left' : 'center', vertical: 'middle' };
+      c.border = allBordersBlack;
+      if (isTotal) c.fill = { type: 'pattern', pattern: 'solid', fgColor: LAVENDER };
+    });
+  };
+
+  let rowIdx = HEADER_ROW + 1;
+  sheets.forEach((s, i) => {
+    const su = s.summary;
+    const remain = Math.max(0, su.total - su.passed - su.na);
+    writeDataRow(rowIdx, [i + 1, s.sheetName, su.passed, su.failed, su.pending, su.na, remain, su.total], false);
+    totals.passed += su.passed;
+    totals.failed += su.failed;
+    totals.pending += su.pending;
+    totals.na += su.na;
+    totals.remain += remain;
+    totals.total += su.total;
+    rowIdx += 1;
+  });
+
+  writeDataRow(
+    rowIdx,
+    ['', 'Total', totals.passed, totals.failed, totals.pending, totals.na, totals.remain, totals.total],
+    true,
+  );
+}
+
+/**
+ * Append one BM-2-901-13 testcase sheet to the given workbook. Sheet content
+ * (layout, summary band, data rows, auto-filter, protection) is identical to
+ * the single-sheet `renderXlsx` output — only the sheet name differs.
+ */
+function addTestcaseSheet(
+  wb: ExcelJS.Workbook,
+  sheetName: string,
+  summary: ScreenSummary,
+  rows: TestCaseRow[],
+  specLink: string,
+): void {
+  const ws = wb.addWorksheet(sheetName, {
+    views: [{ state: 'frozen', ySplit: 0, xSplit: 0 }],
+  });
+
+  // -- Column widths matching template_report.xlsx (Sample sheet) --
+  ws.columns = [
+    { width: 20 },    // A — TC ID (wider to fit long flow IDs like FLOW-KUDO-…)
+    { width: 12.5 },  // B — Screen/Function
+    { width: 15.38 }, // C — Big item
+    { width: 16.25 }, // D — Medium item
+    { width: 17 },    // E — Test Object
+    { width: 25.5 },  // F — Pre-condition
+    { width: 24.88 }, // G — Test Data
+    { width: 24.88 }, // H — Steps
+    { width: 41 },    // I — Expected results
+    { width: 12 },    // J — Priority
+    { width: 13.5 },  // K — Testcase type
+    { width: 15.88 }, // L — Test Result
+    { width: 13.5 },  // M — Executed Date
+    { width: 16.5 },  // N — Test Executor
+    { width: 23 },    // O — Test Environment
+    { width: 29 },    // P — Note
+  ];
+
+  // -- Top metadata band (rows 1-4) — shared BM-2-901-13 masthead --
+  renderReportHeaderBand(wb, ws, `${summary.screen.toUpperCase()} TESTCASE`);
+  // Materialize rows 5..8 so the summary band + row-9 spacer land at the right offsets.
+  for (let r = 5; r <= 8; r++) ws.getRow(r);
 
   // -- Row 5: spacer (height auto-fit). --
 
@@ -348,7 +449,12 @@ function addTestcaseSheet(
   const emittedGroups = new Set<string>();
 
   function emitGroup(groupName: string, groupRows: TestCaseRow[]): void {
-    const divider = ws.addRow(['', groupName]);
+    // Column A (TC ID) must stay TRULY blank on a divider — never write '' here. COUNTA counts
+    // empty-string cells, so an '' in A made the generated total (=COUNTA(A15:A…)) over-count by
+    // one per group divider when recalculated (e.g. in Google Sheets). Set only the group name in B;
+    // the lavender band still spans every column via the fill loop below (style only, no value).
+    const divider = ws.addRow([]);
+    divider.getCell(2).value = groupName;
     divider.getCell(2).font = { bold: true };
     divider.eachCell({ includeEmpty: false }, (cell) => {
       cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: CATEGORY_FILL } };

package/src/generators/gherkin-parser/index.ts

@@ -37,6 +37,13 @@ export interface ParsedScenario {
   stepsName?: string;   // set when scenario has @steps:<name> — marks it as a reusable block
   extendsName?: string; // set when scenario has @extend:<name> — merges base steps inline
   hookType?: 'beforeAll' | 'afterEach' | 'afterAll'; // set when scenario has @beforeAll/@afterEach/@afterAll
+  /**
+   * Comment lines inside the scenario body (between its `Scenario:` line and the next
+   * scenario), leading `# ` stripped. `@cucumber/gherkin` keeps comments in a separate
+   * top-level array; we range-attach them here so the exporter can surface a @manual
+   * scenario's `# Tester verifies:` procedure (its only "steps") in the delivery report.
+   */
+  comments?: string[];
 }
 
 export interface ParsedFeature {
@@ -82,17 +89,53 @@ export class GherkinParser {
     const pathMatch = description.match(/^\s*Path:\s*(.+)$/m);
     const path = pathMatch ? pathMatch[1].trim() : undefined;
 
+    const scenarios = this.parseScenarios(feature);
+    this.attachScenarioComments(gherkinDocument, feature, scenarios);
+
     return {
       name: feature.name,
       description,
       path,
       tags,
       background: this.parseBackground(feature),
-      scenarios: this.parseScenarios(feature),
+      scenarios,
       sourceFile: filePath,
     };
   }
 
+  /**
+   * Range-attach top-level Gherkin comments to the scenario whose body contains them.
+   * A comment belongs to scenario i when its line is after scenario i's `Scenario:` line
+   * and before scenario i+1's header (its first tag line, or its `Scenario:` line). The
+   * leading `# ` is stripped. Used to surface a @manual scenario's tester-procedure comments
+   * (its only "steps") in the delivery report.
+   */
+  private attachScenarioComments(
+    doc: Messages.GherkinDocument,
+    feature: Messages.Feature,
+    scenarios: ParsedScenario[]
+  ): void {
+    const comments = doc.comments || [];
+    if (!comments.length) return;
+    const scenChildren = feature.children
+      .filter((c) => c.scenario)
+      .map((c) => c.scenario!);
+    // Same filter/order as parseScenarios → indices line up with `scenarios`.
+    for (let i = 0; i < scenChildren.length && i < scenarios.length; i++) {
+      const startLine = scenChildren[i].location.line;
+      const next = scenChildren[i + 1];
+      let endLine = Number.POSITIVE_INFINITY;
+      if (next) {
+        const tagLines = (next.tags || []).map((t) => t.location.line);
+        endLine = Math.min(next.location.line, ...(tagLines.length ? tagLines : [next.location.line]));
+      }
+      const body = comments
+        .filter((cm) => cm.location.line > startLine && cm.location.line < endLine)
+        .map((cm) => cm.text.replace(/^\s*#\s?/, '').replace(/\s+$/, ''));
+      if (body.length) scenarios[i].comments = body;
+    }
+  }
+
   /**
    * Parse background steps
    */