@kkeve/suite 0.0.19 → 0.0.20

package/dist/dsl/index.d.ts

@@ -9,7 +9,7 @@
  * 分层：DB 装载 / 内嵌场景展开 / 元素库 source 跳解析 / 变量表查询全部留在
  * 调用方（见 eve-backend 的 dslLoader）。这里只做纯函数投影。
  */
-export { toDecorator, type DslHop, type DslValue, type DslExpectation, type DslStep, type DslVariableRow, type ToDecoratorOptions, } from './toDecorator.js';
+export { toDecorator, stepExpectedText, type DslHop, type DslValue, type DslExpectation, type DslStep, type DslVariableRow, type ExpectedRenderContext, type ToDecoratorOptions, } from './toDecorator.js';
 /** 语义别名：调用方按「生成一份装饰器 spec」的语义引用时更直观 */
 export { toDecorator as generateDecoratorSpec } from './toDecorator.js';
 export { STEP_OPERATIONS, ASSERT_OPERATIONS, TEXT_ONLY_ASSERT_OPERATIONS, EXPECTED_VALUE_CTYPES, COMPARISON_EXPRESSIONS, isKnownOperation, isKnownAssert, isTextOnlyAssert, parseComparison, type StepOperation, } from './ops.js';

package/dist/dsl/index.js

@@ -11,9 +11,10 @@
  * 调用方（见 eve-backend 的 dslLoader）。这里只做纯函数投影。
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseComparison = exports.isTextOnlyAssert = exports.isKnownAssert = exports.isKnownOperation = exports.COMPARISON_EXPRESSIONS = exports.EXPECTED_VALUE_CTYPES = exports.TEXT_ONLY_ASSERT_OPERATIONS = exports.ASSERT_OPERATIONS = exports.STEP_OPERATIONS = exports.generateDecoratorSpec = exports.toDecorator = void 0;
+exports.parseComparison = exports.isTextOnlyAssert = exports.isKnownAssert = exports.isKnownOperation = exports.COMPARISON_EXPRESSIONS = exports.EXPECTED_VALUE_CTYPES = exports.TEXT_ONLY_ASSERT_OPERATIONS = exports.ASSERT_OPERATIONS = exports.STEP_OPERATIONS = exports.generateDecoratorSpec = exports.stepExpectedText = exports.toDecorator = void 0;
 var toDecorator_js_1 = require("./toDecorator.js");
 Object.defineProperty(exports, "toDecorator", { enumerable: true, get: function () { return toDecorator_js_1.toDecorator; } });
+Object.defineProperty(exports, "stepExpectedText", { enumerable: true, get: function () { return toDecorator_js_1.stepExpectedText; } });
 /** 语义别名：调用方按「生成一份装饰器 spec」的语义引用时更直观 */
 var toDecorator_js_2 = require("./toDecorator.js");
 Object.defineProperty(exports, "generateDecoratorSpec", { enumerable: true, get: function () { return toDecorator_js_2.toDecorator; } });

package/dist/dsl/toDecorator.d.ts

@@ -96,3 +96,20 @@ export interface ToDecoratorOptions {
 }
 /** 生成装饰器脚本源码（UTF-8 文本） */
 export declare function toDecorator(options: ToDecoratorOptions): string;
+/** 计算 expected 文案所需的最小上下文（与脚本投影共用，保证报告与脚本同文案） */
+export interface ExpectedRenderContext {
+    env: string;
+    variableList?: DslVariableRow[];
+    account?: {
+        name: string;
+        password: string;
+    };
+}
+/**
+ * 步骤 expected 文案的**公开**入口。
+ *
+ * 投影脚本（toDecorator）与报告 outline（run-dsl-task / report-data）必须产出
+ * 同一份文案，否则会出现「报告的预期」与「评测 Agent 看到的预期」不一致 ——
+ * 那正是「报错4」这类标签被当成字面量去页面搜索的根因。调用方统一走这里。
+ */
+export declare function stepExpectedText(step: DslStep, ctx: ExpectedRenderContext): string;

package/dist/dsl/toDecorator.js

@@ -21,6 +21,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toDecorator = toDecorator;
+exports.stepExpectedText = stepExpectedText;
 const ops_js_1 = require("./ops.js");
 // ─── 生成入口 ────────────────────────────────────────────────────────
 /** 生成装饰器脚本源码（UTF-8 文本） */
@@ -96,8 +97,7 @@ function renderStep(d, ctx) {
     }
     const out = [];
     const stepText = String(d.text || op);
-    const expTexts = (d.expectation || []).map((e) => String(e.text || '')).filter(Boolean);
-    const expected = expTexts.length ? expTexts.join('；') : '操作完成，页面正常响应';
+    const expected = expectedTextOf(d.expectation || [], (e) => resolveExpectationValue(e, ctx));
     const chain = chainExpr(d.context);
     const expLines = [];
     for (const e of d.expectation || []) {
@@ -106,7 +106,7 @@ function renderStep(d, ctx) {
             expLines.push(a);
     }
     const emit = (body) => {
-        out.push(`await keveGoal({ step: ${q(stepText)}, expected: ${q(expected)}${reactOption(d)} }, async () => {`);
+        out.push(`await keveGoal({ step: ${q(stepText)}, expected: ${q(expected)} }, async () => {`);
         for (const b of [...body, ...expLines])
             out.push(`  ${b}`);
         out.push(`});`);
@@ -232,7 +232,7 @@ function renderStep(d, ctx) {
             // 区域截图容错：元素不在当前页面（权限阻断等）时降级为整页截图，
             // 是否一致由基线比对决定，截图本身不做权限硬门。
             if (shotChain) {
-                out.push(`await keveGoal({ step: ${q(stepText)}, expected: ${q(expected)}${reactOption(d)} }, async () => {`);
+                out.push(`await keveGoal({ step: ${q(stepText)}, expected: ${q(expected)} }, async () => {`);
                 out.push(`  try {`);
                 out.push(`    await engine.screenshot(${q(shotName)}, ${shotChain});`);
                 out.push(`  } catch (_shotErr: any) {`);
@@ -275,7 +275,8 @@ function renderOpenPageWithGates(d, gates, ctx) {
     const stepText = String(d.text || 'OPEN_PAGE');
     const gateTexts = gates.map((g) => String(g.text || '')).filter(Boolean);
     const gateExpects = gates
-        .flatMap((g) => (g.expectation || []).map((e) => String(e.text || '')))
+        .filter((g) => (g.expectation || []).length > 0)
+        .map((g) => expectedTextOf(g.expectation || [], (e) => resolveExpectationValue(e, ctx)))
         .filter(Boolean);
     const expected = [...gateTexts, ...gateExpects].filter(Boolean).join('；') || '打开目标页面并等待就绪响应';
     const resolved = resolveOpenPage(d, ctx);
@@ -299,51 +300,143 @@ function renderOpenPageWithGates(d, gates, ctx) {
                 body.push(`await __gate${gi}; // 等 ${String(g.text || '就绪响应')}`);
         });
     }
-    out.push(`await keveGoal({ step: ${q(stepText)}, expected: ${q(expected)}${reactOption(d)} }, async () => {`);
+    out.push(`await keveGoal({ step: ${q(stepText)}, expected: ${q(expected)} }, async () => {`);
     for (const b of body)
         out.push(`  ${b}`);
     out.push(`});`);
     return out;
 }
-// ─── 断言转译 ────────────────────────────────────────────────────────
 /**
- * 步骤是否只有「纯文案期望」，必须依赖 LLM 才能判定。
+ * 步骤 expected 文案的**公开**入口。
  *
- * 平台 DSL 里有两类 expectation：
- *  - 可执行断言（ELEMENT_NOT_EXIST / TEXT_EXIST …）→ 转译成 engine 断言，
- *    成败在脚本里已经确定，无需再看页面；
- *  - 纯文案载体（TEXT / 无 type）→ 不产生任何断言，只以文字描述预期，
- *    脚本无法自证，只能交给 Agent 观察页面后判定。
+ * 投影脚本（toDecorator）与报告 outline（run-dsl-task / report-data）必须产出
+ * 同一份文案，否则会出现「报告的预期」与「评测 Agent 看到的预期」不一致 ——
+ * 那正是「报错4」这类标签被当成字面量去页面搜索的根因。调用方统一走这里。
+ */
+function stepExpectedText(step, ctx) {
+    const renderCtx = {
+        env: ctx.env,
+        variableList: ctx.variableList || [],
+        account: ctx.account,
+    };
+    return expectedTextOf(step.expectation || [], (e) => resolveExpectationValue(e, renderCtx));
+}
+/**
+ * 步骤的 expected 文案 —— 喂给评测 Agent 判断「预期是否真的达成」。
+ *
+ * 平台 expectation[].text 常常只是录制期标签（「报错1」「报错4」），不携带
+ * 任何可判定语义；真实预期藏在同一条 expectation 的 type + value + context 里
+ * （如 ELEMENT_NOT_EXIST + includes「业务逻辑错误」= 页面不应出现该错误）。
+ * 只把标签交给评测 Agent，它会去页面上找字面量「报错4」并据此误判失败。
  *
- * 只有第二类（且该步骤没有可执行断言）才需要保留 Agent Re-Act。
+ * 因此按「可执行断言语义优先、标签作为备注」组装：
+ *   - 有可执行断言 → 渲染成人话（页面不存在包含「业务逻辑错误」的内容）；
+ *   - 纯文案载体（TEXT / 无 type）→ 标签本身就是人话，直接采用；
+ *   - 一个断言都渲染不出来时，退回平台标签，最后兜底为通用文案。
  */
-function needsAgentJudge(d) {
-    const expects = d.expectation || [];
-    if (!expects.length)
-        return false;
-    const hasExecutable = expects.some((e) => {
+function expectedTextOf(expectations, resolveValue) {
+    const semantic = [];
+    const labelOnly = [];
+    for (const e of expectations) {
+        const label = String(e.text || '').trim();
         const type = String(e.type || '');
-        return type && !(0, ops_js_1.isTextOnlyAssert)(type);
-    });
-    if (hasExecutable)
-        return false;
-    return expects.some((e) => {
-        const type = String(e.type || '');
-        return !type || (0, ops_js_1.isTextOnlyAssert)(type);
+        if (!type || (0, ops_js_1.isTextOnlyAssert)(type)) {
+            if (label)
+                labelOnly.push(label);
+            continue;
+        }
+        const phrase = describeExpectation(e, resolveValue(e));
+        // 未知断言在 renderExpectation 里会确定性报错；这里不能让 expected 抢先崩，
+        // 退化成标签即可，真正的失败由断言渲染抛出。
+        if (phrase)
+            semantic.push(label && !phrase.includes(label) ? `${phrase}（${label}）` : phrase);
+        else if (label)
+            labelOnly.push(label);
+    }
+    const parts = [...semantic, ...labelOnly].filter(Boolean);
+    return parts.length ? parts.join('；') : '操作完成，页面正常响应';
+}
+/** 单条可执行断言 → 人类可读预期；返回 null 表示无法给出语义（由调用方兜底） */
+function describeExpectation(e, val) {
+    const type = String(e.type || '');
+    const target = describeChain(e.context);
+    const value = String(val ?? '');
+    switch (type) {
+        case 'ELEMENT_EXIST':
+            return `页面存在${target}`;
+        case 'ELEMENT_NOT_EXIST':
+            return `页面不存在${target}`;
+        case 'ELEMENT_VISIBLE':
+            return `${target}可见`;
+        case 'ELEMENT_NOT_VISIBLE':
+            return `${target}不可见`;
+        case 'TEXT_EXIST':
+            if (isPageTitleAssertion(e))
+                return `页面标题包含「${value}」`;
+            return `页面存在包含「${value}」的内容${target}`;
+        case 'TEXT_NOT_EXIST':
+            if (!value.trim())
+                return null;
+            return `页面不存在包含「${value}」的内容${target}`;
+        case 'TEXT_EQUAL':
+            return `元素${target}文本等于「${value}」`;
+        case 'EXPECTED_VALUE': {
+            const ctype = String(e.ctype || 'text').toLowerCase();
+            const { mode, negated } = (0, ops_js_1.parseComparison)(String(e.cexpression || 'include'));
+            const dim = { text: '文本', class: '类名', placeholder: '占位提示', style: '样式', index: '元素个数' }[ctype] || ctype;
+            if (ctype === 'index')
+                return `元素${target}个数等于 ${value}`;
+            const op = mode === 'eq' ? (negated ? '不等于' : '等于') : (negated ? '不包含' : '包含');
+            return `元素${target}的${dim}${op}「${value}」`;
+        }
+        case 'EXPECTED__PAGET_VALUE': {
+            const ctype = String(e.ctype || 'url').toLowerCase();
+            const { mode, negated } = (0, ops_js_1.parseComparison)(String(e.cexpression || 'eq'));
+            const dim = ctype === 'title' ? '标题' : '地址';
+            const op = mode === 'eq' ? (negated ? '不等于' : '等于') : (negated ? '不包含' : '包含');
+            return `页面${dim}${op}「${value}」`;
+        }
+        case 'SCREEN_SHOT_COMPARE':
+        case 'SCREENSHOT_COMPARE':
+        case 'IMAGE_COMPARE':
+            return `页面截图与基线「${value || e.text || ''}」一致`;
+        default:
+            return null;
+    }
+}
+/** 定位链 → 人类可读描述（评测 Agent 据此知道「在哪个区域」观察） */
+function describeChain(context) {
+    let hops;
+    try {
+        hops = collectHops(context);
+    }
+    catch {
+        return '';
+    }
+    if (!hops.length)
+        return '';
+    // 单跳文本包含：平台最常见的「页面不应出现某文案」录制形态
+    if (hops.length === 1 && (hops[0].type === 'includes' || hops[0].type === 'text')) {
+        return `包含「${hops[0].value.trim()}」的元素`;
+    }
+    const parts = hops.map((h) => {
+        const text = h.value.trim();
+        if (h.type === 'includes' || h.type === 'text')
+            return `包含「${text}」`;
+        if (h.type === 'selector')
+            return `选择器「${text}」`;
+        return `${h.type}=「${text}」`;
     });
+    return `（${parts.join(' → ')}）`;
 }
 /**
- * keveGoal 的 react 参数片段。
+ * 渲染一条 expectation 为 engine 断言；返回 null 表示「纯文案载体，不产生断言」。
  *
- * 平台 DSL 是确定性录制产物：凡能自证的步骤都显式 react: false，跳过 Agent
- * Re-Act —— 否则每个步骤都会额外发起一轮 LLM 探索，既拖长整体耗时至超出
- * Cypress 用例超时（表现为「任务卡住」），也会让「报错1」这类仅作平台标签的
- * expected 文案参与最终结论。
+ * 注意投影脚本**不输出 `react: false`**：可执行断言只证明预期的一个子集，
+ * fn 执行成功不等于 expected 已达成，所以每个 goal 都保留评测阶段 —— Agent
+ * 先观察真实页面评测，达成即放行，未达成再继续探索；断言失败由引擎侧统一
+ * 参与终局覆盖，不允许被评审判成 pass。
  */
-function reactOption(d) {
-    return needsAgentJudge(d) ? '' : ', react: false';
-}
-/** 渲染一条 expectation；返回 null 表示「纯文案载体，不产生断言」 */
 function renderExpectation(e, ctx) {
     const type = String(e.type || '');
     // 无 type / TEXT：纯「期望文案」载体，只喂 keveGoal.expected，不是断言

package/dist/engine-cypress/keveGoal.d.ts

@@ -17,16 +17,6 @@ export interface KeveGoalCallOptions {
     precondition?: string;
     step: string;
     expected: string;
-    /**
-     * 是否在 fn 之后追加一轮 Agent Re-Act 做最终判定。
-     *
-     * 默认 true（AI 场景 / 手写用例）：fn 只是前置动作与确定性校验，预期是否真正
-     * 达成由 Agent 观察真实页面后判定。
-     *
-     * DSL 投影脚本会显式传 false：整条链路的判定已由确定性断言给出，Re-Act 只会
-     * 额外消耗 LLM 预算，并让「报错1」这类平台标签参与结论。
-     */
-    react?: boolean;
 }
 /** agent Re-Act 的结果（P0-3 接入；未接入时由 fn 结果直接判定） */
 export interface CyGoalExploreResult {

package/dist/engine-cypress/keveGoal.js

@@ -75,7 +75,6 @@ function createCyKeveGoal(engine) {
         let fnErrorRaw;
         let fnResult;
         let fnBlocked = false;
-        const reactEnabled = options.react !== false;
         const fnSource = fn?.toString() || undefined;
         const owned = !(0, shotBuffer_js_1.isGoalShotDiffCaptureActive)();
         if (owned)
@@ -140,31 +139,12 @@ function createCyKeveGoal(engine) {
             };
             console.log(`[keveGoal] 📊 "${options.step}" 截图差异超阈值 — 确定性失败`);
         }
-        else if (!reactEnabled) {
-            // 确定性模式：断言是否通过就是结论，不再发起 LLM 探索。
-            reactResult = {
-                expectedMet: !fnError,
-                conclusion: fnError ? 'fail' : 'pass',
-                actions: [{
-                        action: {
-                            tool: 'done',
-                            verdict: fnError ? 'fail' : 'pass',
-                            text: fnError ? `Assertion failed: ${fnError}` : '确定性断言全部通过',
-                        },
-                        toolOutput: '',
-                        result: 'ok',
-                    }],
-                agentScreenshots: [],
-            };
-            logLine(fnError
-                ? `[keveGoal] ⚙️ "${options.step}" 确定性模式：fn 失败，跳过 Agent Re-Act`
-                : `[keveGoal] ⚙️ "${options.step}" 确定性模式：fn 通过，跳过 Agent Re-Act`);
-        }
         else {
-            // fn 成功 / 失败都交给探索器（若引擎入口注册了 AI Re-Act）。
-            // fn 只是前置确定性校验，@keveGoal 的预期是否真正达成必须由 Agent
-            // 观察真实页面后给出最终结论 —— 即便 fn 已通过，也要产出推理轨迹与
-            // 执行后截图，否则报告里会缺少 AI 推理日志。
+            // fn 成功 / 失败都交给评测器。fn 只是前置动作与确定性校验：
+            //  - fn 成功 ≠ expected 达成（fn 可能只覆盖预期的一个子集）；
+            //  - fn 失败 ≠ 不可恢复（普通运行时错误下页面可能仍可探索自愈）。
+            // 「先评测、再决定放行还是探索」由这一轮承担：Agent 先观察真实页面评测
+            // expected，达成即 done(pass) 放行，未达成再继续探索。
             let explored;
             if (explorer) {
                 try {

package/dist/engine-playwright/keve-test.d.ts

@@ -32,13 +32,6 @@ export interface KeveGoalCallOptions {
     precondition?: string;
     step: string;
     expected: string;
-    /**
-     * 是否在 fn 之后追加一轮 Agent Re-Act 做最终判定。
-     *
-     * 默认 true（AI 场景 / 手写用例）；DSL 投影脚本传 false，判定完全由确定性
-     * 断言给出，避免为每个步骤额外消耗一轮 LLM。
-     */
-    react?: boolean;
 }
 type KeveFixture = {
     keveGoal: (options: KeveGoalCallOptions, fn?: () => Promise<void>) => Promise<void>;

package/dist/engine-playwright/keve-test.js

@@ -189,7 +189,6 @@ exports.test = test_1.test.extend({
             let fnErrorRaw; // 原始错误对象（ScreenshotDiffError 等带结构的错误需要保留结构）
             let fnResult; // fn 返回值透传（flow 产物，如 createDashboard 的看板名）
             let fnBlocked = false; // true when fn error is environment-blocked (skip agent Re-Act)
-            const reactEnabled = options.react !== false;
             // 截图对比：fn 前开缓冲、fn 后收集 —— engine.expectScreenshot 的结果经此进 attachment
             (0, screenshotDiff_js_1.beginGoalShotDiffCapture)();
             if (fn) {
@@ -298,27 +297,6 @@ exports.test = test_1.test.extend({
                         conclusion: 'fail',
                     };
                 }
-                else if (!reactEnabled) {
-                    // 确定性模式（DSL 投影脚本）：断言结果即结论，不再发起 LLM 探索。
-                    console.log(fnError
-                        ? `[keveGoal] ⚙️ "${options.step}" deterministic mode: fn failed — skipping agent Re-Act`
-                        : `[keveGoal] ⚙️ "${options.step}" deterministic mode: fn passed — skipping agent Re-Act`);
-                    reactResult = {
-                        expectedMet: !fnError,
-                        actions: [{
-                                action: {
-                                    tool: 'done',
-                                    verdict: fnError ? 'fail' : 'pass',
-                                    text: fnError ? `Assertion failed: ${fnError}` : '确定性断言全部通过',
-                                },
-                                toolOutput: '',
-                                result: 'ok',
-                            }],
-                        finalSnapshot: '',
-                        agentScreenshots: [],
-                        conclusion: fnError ? 'fail' : 'pass',
-                    };
-                }
                 else {
                     // ── Per-goal timeout: prevent one slow goal from exhausting the test timeout ──
                     // Default 300s per goal; total test timeout should be ≥ (goals × 300s + overhead)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kkeve/suite",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "description": "AI-powered full-stack test agent CLI - static analysis, unit test, component test, E2E test, execute, evaluate, and report",
   "license": "MIT",
   "bin": {

package/scripts/run-dsl-task.mjs

@@ -134,8 +134,12 @@ function normalizeStep(step) {
  * 投影 DSL 步骤为报告 outline，语义与 toDecorator 的 keveGoal 参数保持一致。
  * OPEN_PAGE 后紧跟的 WAIT_RESPONSE 会合并进同一个导航步骤，避免报告步骤数
  * 与脚本实际 keveGoal 数不一致。
+ *
+ * expected 文案统一走 stepExpectedText（与脚本投影同一个函数）：报告里展示的
+ * 预期与评测 Agent 读到的预期必须逐字一致，否则平台标签（「报错4」）会在报告
+ * 与评测两侧产生不同解读。
  */
-function buildCaseSteps(dslList) {
+function buildCaseSteps(dslList, ctx, stepExpectedText) {
   const steps = [];
   for (let i = 0; i < dslList.length; i++) {
     const d = dslList[i];
@@ -149,7 +153,8 @@ function buildCaseSteps(dslList) {
       if (gates.length) {
         const gateTexts = gates.map((g) => String(g?.text || '')).filter(Boolean);
         const gateExpects = gates
-          .flatMap((g) => (g?.expectation || []).map((e) => String(e?.text || '')))
+          .filter((g) => (g?.expectation || []).length > 0)
+          .map((g) => stepExpectedText(g, ctx))
           .filter(Boolean);
         steps.push({
           step: String(d?.text || 'OPEN_PAGE'),
@@ -160,8 +165,7 @@ function buildCaseSteps(dslList) {
       }
     }
     const stepText = String(d?.text || op || '');
-    const expTexts = (d?.expectation || []).map((e) => String(e?.text || '')).filter(Boolean);
-    const expected = expTexts.length ? expTexts.join('；') : '操作完成，页面正常响应';
+    const expected = stepExpectedText(d, ctx);
     if (!stepText) continue;
     steps.push({ step: stepText, expected });
   }
@@ -217,7 +221,7 @@ async function main() {
   fs.rmSync(resultFile, { force: true });
   fs.rmSync(manifestFile, { force: true });
 
-  const { toDecorator } = await import(
+  const { toDecorator, stepExpectedText } = await import(
     url.pathToFileURL(path.join(suiteRoot, 'dist/dsl/index.js')).href
   );
 
@@ -233,20 +237,26 @@ async function main() {
     const importFrom = engine === 'cypress'
       ? '@kkeve/suite/engine-cypress'
       : '@kkeve/suite/keve-test';
+    const account = resolveAccount(item.accountInfo || input.accountInfo);
+    const renderCtx = {
+      env: input.env || 'test',
+      variableList: Array.isArray(item.variableList) ? item.variableList : [],
+      account,
+    };
     const code = toDecorator({
       stepGroupId,
       caseName: item.caseName || `用例 ${stepGroupId}`,
       dslList,
-      env: input.env || 'test',
-      variableList: Array.isArray(item.variableList) ? item.variableList : [],
-      account: resolveAccount(item.accountInfo || input.accountInfo),
+      env: renderCtx.env,
+      variableList: renderCtx.variableList,
+      account: renderCtx.account,
       ssoInject: input.ssoInject !== false,
       importFrom,
     });
 
     const fileName = `sg${stepGroupId}.spec.ts`;
     fs.writeFileSync(path.join(specDir, fileName), code, 'utf-8');
-    const dslSteps = buildCaseSteps(dslList);
+    const dslSteps = buildCaseSteps(dslList, renderCtx, stepExpectedText);
     caseEntries.push({
       caseId: `S${stepGroupId}`,
       stepGroupId,