@taodigital/agents 0.0.0-stage → 1.2.0

package/dist/test-import-agent.js

@@ -0,0 +1,3235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTestCases = parseTestCases;
+exports.headerSignature = headerSignature;
+exports.inferColumnMapping = inferColumnMapping;
+exports.saveColumnMapping = saveColumnMapping;
+exports.loadColumnMapping = loadColumnMapping;
+exports.sanitizeParsedCase = sanitizeParsedCase;
+exports.extractTabularHeaders = extractTabularHeaders;
+exports.scenarioContextKey = scenarioContextKey;
+exports.parseTestCasesWithCache = parseTestCasesWithCache;
+exports.parseJsonWithRepair = parseJsonWithRepair;
+exports.extractFzeRawPairs = extractFzeRawPairs;
+exports.isFunctionizeFormat = isFunctionizeFormat;
+exports.extractGroundedScenarioCandidates = extractGroundedScenarioCandidates;
+exports.extractScenarios = extractScenarios;
+exports.buildSeleniumHints = buildSeleniumHints;
+exports.annotateWithSeleniumHints = annotateWithSeleniumHints;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const app_brain_1 = require("@taodigital/app-brain");
+const core_1 = require("@taodigital/core");
+const llm_js_1 = require("./llm.js");
+const llm_config_js_1 = require("./llm-config.js");
+/**
+ * Best-effort conversion of a Selenium XPath to a semantic Playwright/CSS selector hint.
+ * Returns the converted string if conversion is confident, otherwise returns null.
+ */
+function tryConvertXPathToSemantic(xpath) {
+    if (!xpath || !xpath.trim().startsWith('/'))
+        return null;
+    // data-testid: //[*][@data-testid='X'] or //*[@data-testid="X"]
+    const testIdMatch = xpath.match(/@data-testid\s*=\s*["']([^"']+)["']/);
+    if (testIdMatch)
+        return `[data-testid="${testIdMatch[1]}"]`;
+    // aria-label: //*[@aria-label='X']
+    const ariaLabelMatch = xpath.match(/@aria-label\s*=\s*["']([^"']+)["']/);
+    if (ariaLabelMatch)
+        return `[aria-label="${ariaLabelMatch[1]}"]`;
+    // placeholder: //input[@placeholder='X']
+    const placeholderMatch = xpath.match(/@placeholder\s*=\s*["']([^"']+)["']/);
+    if (placeholderMatch)
+        return `[placeholder="${placeholderMatch[1]}"]`;
+    // id: //*[@id='X'] or //input[@id='X']
+    const idMatch = xpath.match(/@id\s*=\s*["']([^"']+)["']/);
+    if (idMatch)
+        return `#${idMatch[1]}`;
+    // name: //*[@name='X']
+    const nameMatch = xpath.match(/@name\s*=\s*["']([^"']+)["']/);
+    if (nameMatch)
+        return `[name="${nameMatch[1]}"]`;
+    // text content: //button[text()='X'] or //a[contains(text(),'X')]
+    const textExactMatch = xpath.match(/\[text\(\)\s*=\s*["']([^"']{1,60})["']\]/);
+    if (textExactMatch)
+        return `text=${textExactMatch[1]}`;
+    const textContainsMatch = xpath.match(/contains\s*\(\s*text\s*\(\s*\)\s*,\s*["']([^"']{1,60})["']\)/);
+    if (textContainsMatch)
+        return `text=${textContainsMatch[1]}`;
+    // CSS class (only if simple single class): //*[contains(@class,'submit-btn')]
+    const classMatch = xpath.match(/contains\s*\(\s*@class\s*,\s*["']([a-zA-Z0-9_-]+)["']\)/);
+    if (classMatch)
+        return `.${classMatch[1]}`;
+    return null; // XPath too complex to convert; keep as-is with warning
+}
+function platformPrefix(platform) {
+    switch ((platform ?? '').trim().toLowerCase()) {
+        case 'katalon': return 'TC-KAT-';
+        case 'qmetry': return 'TC-QMT-';
+        case 'testrail': return 'TC-TRL-';
+        case 'xray': return 'TC-XRY-';
+        case 'zephyr': return 'TC-ZEP-';
+        case 'functionize': return 'TC-FZE-';
+        case 'azure devops': return 'TC-AZR-';
+        case 'practitest': return 'TC-PTC-';
+        case 'qtest': return 'TC-QTS-';
+        case 'other':
+        case 'generic':
+        case '':
+            return 'TC-IMP-';
+        default: return 'TC-IMP-';
+    }
+}
+function normalizeRef(raw, platform) {
+    const prefix = platformPrefix(platform);
+    const s = raw.trim();
+    if (!s)
+        return s;
+    if (/^TC-[A-Z]{2,6}-/.test(s))
+        return s;
+    const fzeM = s.match(/^fze_([a-f0-9]+)/i);
+    if (fzeM)
+        return `${prefix}${fzeM[1].slice(0, 8).toUpperCase()}`;
+    // TestRail: C12345
+    if (/^C\d+$/.test(s))
+        return `${prefix}${s.slice(1)}`;
+    // Katalon: TC-123 or TC_123
+    if (/^TC[-_]\d+$/i.test(s))
+        return `${prefix}${s.replace(/^TC[-_]/i, '')}`;
+    // QMetry: QT-123 or QM-123
+    if (/^Q[TM]-\d+$/i.test(s))
+        return `${prefix}${s.replace(/^[A-Z]+-/i, '')}`;
+    // Zephyr Scale commonly exports project test keys such as ABC-T123.
+    if ((platform ?? '').trim().toLowerCase() === 'zephyr' && /^[A-Z][A-Z0-9]+-T\d+$/i.test(s))
+        return s;
+    // Xray and Azure DevOps often preserve Jira/work-item keys; keep stable source keys as-is.
+    if (/^[A-Z][A-Z0-9]+-\d+$/i.test(s))
+        return s;
+    // Pure numeric ID
+    if (/^\d+$/.test(s))
+        return `${prefix}${s}`;
+    return s;
+}
+function sanitizeInlineKey(raw) {
+    const cleaned = raw.trim()
+        .replace(/^["']|["']$/g, '')
+        .replace(/^(test\s*)?(data|input|parameter|variable)\s*[:#-]?\s*/i, '')
+        .replace(/[^\w\s.-]/g, ' ')
+        .trim();
+    if (/^[A-Za-z][A-Za-z0-9]*$/.test(cleaned)) {
+        return (cleaned.charAt(0).toLowerCase() + cleaned.slice(1)).slice(0, 60);
+    }
+    const camel = cleaned
+        .split(/[\s.-]+/)
+        .filter(Boolean)
+        .map((part, i) => i === 0 ? part.toLowerCase() : part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+    return camel.replace(/[^\w]/g, '').slice(0, 60) || 'testData';
+}
+function normalizeImportedDataValue(key, value) {
+    if (value == null)
+        return value;
+    const lower = key.toLowerCase();
+    if (/password|passwd|pwd/.test(lower))
+        return '[env:TEST_USER_PASSWORD]';
+    if (/api.?key|access.?key/.test(lower))
+        return '[env:TEST_API_KEY]';
+    if (/token|bearer|jwt/.test(lower))
+        return '[env:TEST_TOKEN]';
+    if (/secret|clientsecret/.test(lower))
+        return '[env:TEST_SECRET]';
+    return value;
+}
+function parseImportedTestData(raw) {
+    if (raw == null)
+        return undefined;
+    if (typeof raw === 'object' && !Array.isArray(raw)) {
+        const flat = {};
+        for (const [k, v] of Object.entries(flattenImportData(raw))) {
+            if (v == null || v === '')
+                continue;
+            const key = sanitizeInlineKey(k);
+            flat[key] = normalizeImportedDataValue(key, v);
+        }
+        return Object.keys(flat).length > 0 ? flat : undefined;
+    }
+    const text = String(raw).trim();
+    if (!text)
+        return undefined;
+    try {
+        const parsed = JSON.parse(text);
+        const obj = parseImportedTestData(parsed);
+        if (obj)
+            return obj;
+    }
+    catch { /* not JSON */ }
+    const out = {};
+    const parts = text.split(/\s*(?:\||;|\n|,(?=\s*[\w .-]+\s*[:=]))\s*/).map(p => p.trim()).filter(Boolean);
+    for (const part of parts) {
+        const m = part.match(/^([^:=]{1,80})\s*[:=]\s*(.+)$/);
+        if (!m)
+            continue;
+        const key = sanitizeInlineKey(m[1]);
+        const value = m[2].trim().replace(/^["']|["']$/g, '');
+        if (key && value)
+            out[key] = normalizeImportedDataValue(key, value);
+    }
+    if (Object.keys(out).length > 0)
+        return out;
+    return { testData: text };
+}
+function flattenImportData(obj, prefix = '') {
+    const flat = {};
+    for (const [k, v] of Object.entries(obj)) {
+        const key = prefix ? `${prefix}.${k}` : k;
+        if (v && typeof v === 'object' && !Array.isArray(v))
+            Object.assign(flat, flattenImportData(v, key));
+        else if (!Array.isArray(v))
+            flat[key] = v;
+    }
+    return flat;
+}
+function mergeTestDataInline(tc, raw) {
+    const parsed = parseImportedTestData(raw);
+    if (!parsed)
+        return;
+    const next = { ...(tc.testDataInline ?? {}) };
+    for (const [k, v] of Object.entries(parsed)) {
+        if (next[k] === undefined || next[k] === '')
+            next[k] = v;
+    }
+    tc.testDataInline = next;
+}
+async function parseTestCases(content, format, tenantId, mapping, scenarioContext, filePath, sourcePlatform) {
+    if (format === 'GHERKIN')
+        return parseGherkin(content);
+    if (format === 'EXCEL' || format === 'CSV') {
+        // If this spreadsheet is actually a Functionize recording (e.g. transposed 2-column or has pageinit),
+        // parse it as Functionize test cases directly instead of failing column mapping.
+        const fzeCheck = tryParseFzeExcel(content, sourcePlatform);
+        if (fzeCheck && fzeCheck.cases.length > 0)
+            return fzeCheck;
+        const raw = parseTabular(content, mapping, sourcePlatform);
+        return {
+            cases: raw.cases.map(c => sanitizeParsedCase(c)).filter((c) => c !== null),
+            errors: raw.errors,
+        };
+    }
+    if (format === 'SPEC')
+        return parseSpecFile(content, filePath);
+    if (format === 'FUNCTIONIZE') {
+        const jsonResult = tryParseJsonCases(content, 'functionize');
+        if (jsonResult)
+            return jsonResult;
+        const xlResult = tryParseFzeExcel(content, sourcePlatform);
+        if (xlResult)
+            return xlResult;
+        return { cases: [], errors: ['No Functionize test cases found in this file'] };
+    }
+    // Try direct JSON parse before invoking AI
+    const jsonResult = tryParseJsonCases(content, sourcePlatform);
+    if (jsonResult)
+        return jsonResult;
+    return aiExtract(content, tenantId, scenarioContext);
+}
+// ─── Column mapping — AI inference + per-tenant persistence ──────────────────
+/** Stable 8-char hex key for a header set (order-independent). */
+function headerSignature(headers) {
+    const normalized = [...headers].map((h) => h.trim().toLowerCase()).sort().join('|');
+    return node_crypto_1.default.createHash('sha256').update(normalized).digest('hex').slice(0, 8);
+}
+/**
+ * Load or infer a column mapping for the given headers.
+ * Order: saved → AI inference → heuristic synonym fallback.
+ */
+async function inferColumnMapping(headers, sampleRows, tenantId) {
+    const signature = headerSignature(headers);
+    // 1. Check saved mapping
+    const saved = await loadColumnMapping(tenantId, signature);
+    if (saved)
+        return { mapping: saved, source: 'saved', signature, headers, sampleRows };
+    // 2. Try AI inference
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(tenantId, 'appBrain').catch(() => null);
+    if (llmCfg) {
+        try {
+            const mapping = await _aiInferMapping(headers, sampleRows, llmCfg);
+            return { mapping, source: 'ai', signature, headers, sampleRows };
+        }
+        catch { /* fall through to heuristic */ }
+    }
+    // 3. Heuristic synonyms (existing colIdx logic)
+    const mapping = _heuristicMapping(headers);
+    return { mapping, source: 'heuristic', signature, headers, sampleRows };
+}
+async function _aiInferMapping(headers, sampleRows, llmCfg) {
+    const headerList = headers.map((h, i) => `${i}: "${h}"`).join(', ');
+    const sampleText = sampleRows.slice(0, 3).map((r, ri) => `Row ${ri + 1}: ` + headers.map((_, i) => `"${(r[i] ?? '').slice(0, 60)}"`).join(', ')).join('\n');
+    const COLUMN_MAP_DEFAULT = `You are a QA tool that maps spreadsheet columns to test-case fields.
+Return ONLY a JSON object — no explanation, no markdown fences.
+Keys are field names, values are zero-based column indices (integers). Omit fields with no good match.
+
+Fields: title, ref, steps, expected, priority, kind, preconditions, data, tags, section, actualResult, comment, stepId, screenshotUrl, status
+
+Field descriptions:
+- title: test case name/description
+- ref: test case ID or reference number
+- steps: test step actions/instructions
+- expected: expected result per step
+- priority: severity or priority level (Critical/High/Medium/Low)
+- kind: test type (Functional/Regression/Smoke/etc)
+- preconditions: setup prerequisites
+- data: test input data or credentials
+- tags: labels or categories
+- section: module, suite, or folder
+- actualResult: what actually happened during test execution
+- comment: notes, observations, or remarks
+- stepId: step number or identifier (Step 1, Step 2, etc)
+- screenshotUrl: URL or path to a screenshot file
+- status: test execution status (Passed/Failed/Skipped/Blocked)
+
+Example output: {"title":0,"ref":1,"steps":3,"expected":4,"priority":5,"actualResult":6,"comment":7}`;
+    const system = await (0, core_1.getAgentPrompt)('test-import-column-map').catch(() => null) ?? COLUMN_MAP_DEFAULT;
+    const user = `Headers (index: name): ${headerList}
+
+Sample data:
+${sampleText}
+
+Map these headers to test-case fields.`;
+    const seed = (0, llm_js_1.deterministicSeed)(`col-map:${headers.join('|').slice(0, 500)}`);
+    const { text } = await (0, llm_js_1.askTracked)(system, user, llmCfg, 256, undefined, { temperature: 0, seed });
+    // Parse — try direct, then bracket slice
+    let obj;
+    try {
+        obj = JSON.parse(text);
+    }
+    catch {
+        const s = text.indexOf('{'), e = text.lastIndexOf('}');
+        if (s < 0 || e <= s)
+            throw new Error('No JSON object in LLM response');
+        obj = JSON.parse(text.slice(s, e + 1));
+    }
+    // Validate: values must be non-negative integers within header range
+    const mapping = {};
+    const fields = ['title', 'ref', 'steps', 'expected', 'priority', 'kind', 'preconditions', 'data', 'tags', 'section', 'actualResult', 'comment', 'stepId', 'screenshotUrl', 'status'];
+    for (const f of fields) {
+        const v = obj[f];
+        if (typeof v === 'number' && Number.isInteger(v) && v >= 0 && v < headers.length) {
+            mapping[f] = v;
+        }
+    }
+    return mapping;
+}
+function _heuristicMapping(headers) {
+    const h = headers.map((s) => s.trim().toLowerCase());
+    const colIdx = (names) => {
+        for (const n of names) {
+            const i = h.indexOf(n);
+            if (i >= 0)
+                return i;
+        }
+        return undefined;
+    };
+    return {
+        title: colIdx(['title', 'name', 'test case', 'test name', 'scenario', 'tc description', 'description', 'test description', 'test case name', 'test case title', 'summary', 'test summary']),
+        ref: colIdx(['ref', 'id', 'tc_id #', 'tc id', 'tc #', 'tc_id', 'test id', 'no', 'case id', 'key', 'test case id', 'tc_ref', 'work item id']),
+        steps: colIdx(['steps', 'step', 'actions', 'test steps', 'action', 'step description', 'test action']),
+        expected: colIdx(['expected', 'expected result', 'expected outcome', 'result', 'expected behavior', 'pass criteria']),
+        priority: colIdx(['priority', 'severity', 'importance', 'criticality']),
+        kind: colIdx(['type', 'kind', 'category', 'test type', 'test category', 'case type']),
+        preconditions: colIdx(['preconditions', 'prerequisites', 'precondition', 'pre-conditions', 'setup', 'pre-requisites']),
+        data: colIdx(['test data', 'data', 'input data', 'test inputs', 'inputs', 'credentials', 'test credentials']),
+        tags: colIdx(['tags', 'label', 'labels', 'tag', 'keywords', 'markers']),
+        section: colIdx(['section', 'folder', 'module', 'group', 'component', 'module/suite', 'suite', 'test suite', 'area', 'feature', 'area path', 'test suite folder', 'subsystem']),
+        actualResult: colIdx(['actual result', 'Actual Result', 'Actual Outcome', 'Actual Behavior', 'actual', 'actual outcome', 'result actual', 'actual behavior', 'observed', 'observed result', 'run result', 'execution result']),
+        comment: colIdx(['comment', 'comments', 'notes', 'note', 'remarks', 'remark', 'observation', 'description', 'review notes', 'tester notes']),
+        stepId: colIdx(['step id', 'step no', 'step #', 'step number', 'no.', '#', 'seq', 'step_no', 'stepno', 'step_id', 'step num']),
+        screenshotUrl: colIdx(['screenshot', 'screenshot url', 'screenshot_url', 'image', 'attachment', 'evidence', 'screen capture', 'screen shot']),
+        status: colIdx(['status', 'test status', 'execution status', 'run status', 'result status', 'pass/fail', 'passed/failed', 'state']),
+    };
+}
+async function saveColumnMapping(tenantId, signature, mapping) {
+    await app_brain_1.AppBrain.saveImportMapping(tenantId, signature, mapping);
+}
+async function loadColumnMapping(tenantId, signature) {
+    return app_brain_1.AppBrain.loadImportMapping(tenantId, signature);
+}
+// Generic/useless test case titles that should be replaced with inferred content.
+const GENERIC_TITLE_RE = /^(test case \d+|untitled|test|home|index|default|unnamed|new test|\d+|tc[-_]?\d*|scenario \d+|step \d+)$/i;
+/**
+ * Infer a meaningful title from test content when the stored title is generic.
+ * Priority: Gherkin Scenario line → expectedResult first line → first meaningful step action.
+ */
+function inferTitle(steps, expectedResult, gherkin) {
+    // 1. Gherkin scenario line (already curated by the recording/authoring tool)
+    if (gherkin) {
+        const m = gherkin.match(/^Scenario(?:\s+Outline)?:\s*(.+)/m);
+        const candidate = m?.[1]?.trim() ?? '';
+        if (candidate && !GENERIC_TITLE_RE.test(candidate))
+            return candidate.slice(0, 200);
+    }
+    // 2. expectedResult — strip "Verify:" prefix, use first meaningful line
+    if (expectedResult && expectedResult.length > 5) {
+        const line = expectedResult.split('\n')[0].trim().replace(/^(verify|expected|assert|check|confirm):\s*/i, '').replace(/^"(.+)"$/, '$1').trim();
+        if (line.length > 5 && line.length < 160 && !GENERIC_TITLE_RE.test(line) && !/\{\{fze\./i.test(line)) {
+            return `Verify ${line}`;
+        }
+    }
+    // 3. First meaningful step action (skip navigate/script/switch boilerplate)
+    const skip = /^(navigate to:|execute script|switch to context|\[conditional)/i;
+    const meaningful = steps.find(s => s.action && s.action.length > 8 && !skip.test(s.action));
+    if (meaningful)
+        return meaningful.action.split('\n')[0].trim().slice(0, 160);
+    return '';
+}
+/**
+ * Automatically expands truncated or superficial test steps (e.g. 1-step table row imports
+ * or 3-step generic boilerplate) into 4 to 5 actionable, sequential steps.
+ */
+function expandTruncatedSteps(title, existingSteps, preconditions, expectedResult, kind) {
+    if (existingSteps.length >= 4)
+        return existingSteps;
+    const cleanTitle = title
+        .replace(/^(?:verify|validate|check|test|ensure|confirm|assert|block|prevent)\s+/i, '')
+        .trim();
+    const expRes = expectedResult || cleanTitle;
+    const isNegative = kind === 'NEGATIVE' || /\b(block|prevent|reject|deny|invalid|error|fail)\b/i.test(title);
+    // Case 1: 1-step test case (typical of business rule table rows)
+    if (existingSteps.length === 1) {
+        const single = existingSteps[0];
+        const singleAction = single.action.trim();
+        const singleExpected = single.expected.trim() || expRes;
+        if (isNegative) {
+            return [
+                {
+                    stepId: '1',
+                    action: `${preconditions ? `Prerequisites: ${preconditions}. ` : ''}Navigate to the relevant section or form.`,
+                    expected: 'The page or form is displayed and ready for interaction.',
+                },
+                {
+                    stepId: '2',
+                    action: `Open the form or screen for ${cleanTitle}.`,
+                    expected: 'All required fields are displayed and enabled.',
+                },
+                {
+                    stepId: '3',
+                    action: singleAction.startsWith('Attempt') ? singleAction : `Attempt to ${singleAction.charAt(0).toLowerCase() + singleAction.slice(1)}.`,
+                    expected: singleExpected.length > 5 ? singleExpected : 'System detects the invalid input/condition and prevents further processing.',
+                },
+                {
+                    stepId: '4',
+                    action: 'Verify visual error feedback, dialog prompt, or field-level validation message.',
+                    expected: 'A clear, descriptive error or warning message is displayed and transaction transmission is blocked.',
+                },
+                {
+                    stepId: '5',
+                    action: 'Enter valid corrected data or cancel the blocked operation.',
+                    expected: 'System clears the validation error, returns to a stable state, and logs the blocked event if required.',
+                },
+            ];
+        }
+        else {
+            return [
+                {
+                    stepId: '1',
+                    action: `${preconditions ? `Prerequisites: ${preconditions}. ` : ''}Navigate to the relevant section or dashboard.`,
+                    expected: 'The section or dashboard is displayed.',
+                },
+                {
+                    stepId: '2',
+                    action: `Open the feature or form for ${cleanTitle}.`,
+                    expected: 'The feature or form is loaded with all applicable fields.',
+                },
+                {
+                    stepId: '3',
+                    action: singleAction,
+                    expected: 'Input is accepted and field validation passes successfully.',
+                },
+                {
+                    stepId: '4',
+                    action: 'Submit the form or trigger the primary action.',
+                    expected: singleExpected,
+                },
+                {
+                    stepId: '5',
+                    action: 'Verify the outcome, returned confirmation details, and system state.',
+                    expected: 'A confirmation or reference is returned and the relevant system records are updated.',
+                },
+            ];
+        }
+    }
+    // Helper to infer realistic Virginia CVR test data for step parameters
+    const domainData = inferDomainTestData(cleanTitle);
+    // Case 2: 2-step test case -> expand to 4 concrete steps
+    if (existingSteps.length === 2) {
+        return [
+            {
+                stepId: '1',
+                action: `${preconditions ? `Prerequisites: ${preconditions}. ` : ''}Navigate to the relevant section.`,
+                expected: 'The section is displayed.',
+            },
+            {
+                stepId: '2',
+                action: existingSteps[0].action,
+                data: existingSteps[0].data || domainData,
+                expected: existingSteps[0].expected || 'Field input is validated and accepted.',
+            },
+            {
+                stepId: '3',
+                action: existingSteps[1].action,
+                expected: existingSteps[1].expected || expRes,
+            },
+            {
+                stepId: '4',
+                action: 'Verify the final status and system state.',
+                expected: 'The operation completes successfully and relevant records are updated.',
+            },
+        ];
+    }
+    // Case 3: 3-step test case -> always expand to 5 concrete steps
+    if (existingSteps.length === 3) {
+        const s1 = existingSteps[0].action.toLowerCase();
+        const s2 = existingSteps[1].action.toLowerCase();
+        const isGenericBoilerplate = (s1.includes('log in') || s1.includes('login')) && (s2.includes('navigate') || s2.includes('open'));
+        if (isGenericBoilerplate) {
+            return [
+                {
+                    stepId: '1',
+                    action: existingSteps[0].action,
+                    expected: existingSteps[0].expected || 'User is authenticated and redirected to the dashboard.',
+                },
+                {
+                    stepId: '2',
+                    action: existingSteps[1].action,
+                    expected: existingSteps[1].expected || 'Section is displayed.',
+                },
+                {
+                    stepId: '3',
+                    action: `Configure the parameters for ${cleanTitle} and complete all required fields.`,
+                    data: domainData,
+                    expected: 'Form data is populated and client-side validations confirm readiness.',
+                },
+                {
+                    stepId: '4',
+                    action: existingSteps[2].action,
+                    expected: existingSteps[2].expected || expRes,
+                },
+                {
+                    stepId: '5',
+                    action: 'Verify the operation outcome and returned confirmation details.',
+                    expected: 'The operation completes with confirmed status and relevant records are updated.',
+                },
+            ];
+        }
+        else {
+            // 3 substantive steps: wrap with prerequisite setup and post-condition audit
+            return [
+                {
+                    stepId: '1',
+                    action: `${preconditions ? `Prerequisites: ${preconditions}. ` : ''}Open the form for ${cleanTitle}.`,
+                    expected: 'The form is displayed and ready for entry.',
+                },
+                {
+                    stepId: '2',
+                    action: existingSteps[0].action,
+                    data: existingSteps[0].data || domainData,
+                    expected: existingSteps[0].expected || 'Step input is validated.',
+                },
+                {
+                    stepId: '3',
+                    action: existingSteps[1].action,
+                    expected: existingSteps[1].expected || 'Validation passes.',
+                },
+                {
+                    stepId: '4',
+                    action: existingSteps[2].action,
+                    expected: existingSteps[2].expected || expRes,
+                },
+                {
+                    stepId: '5',
+                    action: 'Verify the final outcome, database updates, and system state.',
+                    expected: 'The operation completes with confirmed status and the system state is updated.',
+                },
+            ];
+        }
+    }
+    return existingSteps;
+}
+function inferDomainTestData(_text) {
+    // Domain-agnostic: do not inject domain-specific test data into step templates.
+    // Concrete test data must come from the source document via the LLM prompt.
+    return undefined;
+}
+/**
+ * Coerce an untrusted (LLM- or client-supplied) object into a valid ParsedTestCase.
+ * Returns null when the object cannot represent a test case.
+ */
+function sanitizeParsedCase(tc) {
+    if (!tc?.title || typeof tc.title !== 'string')
+        return null;
+    const rawSteps = Array.isArray(tc.steps) ? tc.steps : [];
+    const steps = rawSteps
+        .filter((s) => s && (s.action || s.expected))
+        .map((s, i) => ({
+        stepId: s.stepId ? String(s.stepId) : String(i + 1),
+        action: String(s.action ?? ''),
+        data: s.data ? String(s.data) : undefined,
+        expected: String(s.expected ?? ''),
+        actualResult: s.actualResult ? String(s.actualResult) : undefined,
+        comment: s.comment ? String(s.comment) : undefined,
+        screenshotUrl: s.screenshotUrl ? String(s.screenshotUrl) : undefined,
+    }));
+    const expectedResult = String(tc.expectedResult ?? tc.title);
+    if (steps.length === 0)
+        steps.push({ stepId: '1', action: 'Execute test case', expected: expectedResult });
+    // Normalize title: enforce max length, detect and replace generic fallbacks
+    let title = tc.title.trim().slice(0, 255);
+    if (GENERIC_TITLE_RE.test(title) || title.length < 3) {
+        const inferred = inferTitle(steps, expectedResult, tc.gherkin ? String(tc.gherkin) : undefined);
+        if (inferred)
+            title = inferred.slice(0, 255);
+    }
+    if (!title)
+        return null;
+    const normalizedKind = normalizeKind(String(tc.kind ?? ''));
+    const finalizedSteps = expandTruncatedSteps(title, steps, tc.preconditions ? String(tc.preconditions) : undefined, expectedResult, normalizedKind);
+    return {
+        ref: tc.ref ? String(tc.ref) : undefined,
+        traceTo: tc.traceTo ? String(tc.traceTo) : undefined,
+        caseRefs: Array.isArray(tc.caseRefs) ? tc.caseRefs.filter((r) => r && typeof r === 'object') : undefined,
+        title,
+        kind: normalizedKind,
+        priority: (0, core_1.normalizePriority)(String(tc.priority ?? '')) ?? 'MEDIUM',
+        preconditions: tc.preconditions ? String(tc.preconditions) : undefined,
+        steps: finalizedSteps,
+        expectedResult,
+        actualResult: tc.actualResult ? String(tc.actualResult) : undefined,
+        comment: tc.comment ? String(tc.comment) : undefined,
+        screenshotUrl: tc.screenshotUrl ? String(tc.screenshotUrl) : undefined,
+        status: tc.status ? String(tc.status) : undefined,
+        gherkin: tc.gherkin ? String(tc.gherkin) : undefined,
+        tags: Array.isArray(tc.tags) ? tc.tags.map(String) : [],
+        section: tc.section ? String(tc.section) : undefined,
+        // Preserve recorded form field data from FZE imports so the import route can
+        // promote it to a TestData row and build testDataInline in the DB.
+        testDataInline: tc.testDataInline && typeof tc.testDataInline === 'object' && !Array.isArray(tc.testDataInline)
+            ? tc.testDataInline
+            : undefined,
+    };
+}
+// ─── Spec file parser (Playwright / Cypress / Jest) ──────────────────────────
+function titleFromPythonName(name) {
+    return name
+        .replace(/^test_?/i, '')
+        .replace(/[_-]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/^./, (c) => c.toUpperCase()) || 'Python Selenium test';
+}
+function stripMarkdownCodeWrapper(content, filePath) {
+    const fence = content.match(/```(?:python|py)?\s*([\s\S]*?)```/i);
+    if (fence)
+        return fence[1].trim();
+    if (filePath?.endsWith('.py')) {
+        const headerMatch = content.match(/^#[^\n]*\n(?:\n>?[^\n]*\n)*\n([\s\S]+)$/);
+        if (headerMatch)
+            return headerMatch[1];
+    }
+    return content;
+}
+function pythonLocatorFieldKey(locator, fallbackIdx) {
+    const candidate = locator.match(/@(?:name|id|aria-label|placeholder)\s*=\s*["']([^"']+)["']/)?.[1]
+        ?? locator.match(/By\.(?:NAME|ID)\s*,\s*["']([^"']+)["']/)?.[1]
+        ?? locator.match(/#([A-Za-z][\w-]+)/)?.[1]
+        ?? locator.match(/\[name=["']([^"']+)["']\]/)?.[1];
+    return sanitizeInlineKey(candidate ?? `field${fallbackIdx}`);
+}
+function parsePythonSpecFile(content, filePath) {
+    const py = stripMarkdownCodeWrapper(content, filePath);
+    const lines = py.split('\n');
+    const cases = [];
+    let current = null;
+    let fieldIdx = 1;
+    const filenameTitle = titleFromPythonName((filePath ?? 'python_selenium_test.py').split('/').pop() ?? 'python_selenium_test.py');
+    const flush = () => {
+        if (!current)
+            return;
+        if (current.steps.length === 0)
+            current.steps.push({ action: 'Execute Python test script', expected: 'Script passes without errors' });
+        const expectedSteps = current.steps.filter(s => s.expected);
+        current.expectedResult = current.steps.some(s => s.expected)
+            ? (expectedSteps[expectedSteps.length - 1]?.expected ?? current.expectedResult)
+            : current.expectedResult;
+        cases.push(current);
+        current = null;
+    };
+    const ensureCase = (title = filenameTitle) => {
+        if (!current) {
+            current = {
+                title,
+                kind: 'E2E',
+                priority: 'MEDIUM',
+                section: 'Selenium Python',
+                tags: ['python', 'selenium', 'imported'],
+                steps: [],
+                expectedResult: 'Python Selenium script passes without errors',
+            };
+        }
+        return current;
+    };
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const testDef = line.match(/^def\s+(test_[A-Za-z0-9_]+)\s*\(/);
+        if (testDef) {
+            flush();
+            ensureCase(titleFromPythonName(testDef[1]));
+            continue;
+        }
+        const active = ensureCase();
+        const gotoMatch = line.match(/\.(?:get|goto)\(\s*([ruRU]?)(["'])(.*?)\2\s*\)/);
+        if (gotoMatch) {
+            const url = gotoMatch[3];
+            active.steps.push({ action: `Navigate to ${url}`, expected: 'Page loads successfully' });
+            mergeTestDataInline(active, { startUrl: url });
+            continue;
+        }
+        const sendKeysMatch = line.match(/find_element\s*\(([^)]{0,240})\)\.send_keys\(\s*([ruRU]?)(["'])(.*?)\3\s*\)/);
+        if (sendKeysMatch) {
+            const locatorExpr = sendKeysMatch[1];
+            const value = sendKeysMatch[4];
+            const locatorHint = tryConvertXPathToSemantic(locatorExpr.match(/["']([^"']+)["']\s*$/)?.[1] ?? locatorExpr);
+            const fieldKey = pythonLocatorFieldKey(locatorExpr, fieldIdx++);
+            active.steps.push({
+                action: `Enter value into ${fieldKey}`,
+                data: value,
+                expected: `${fieldKey} accepts the value`,
+                ...(locatorHint ? { comment: `locatorHint: ${locatorHint}` } : {}),
+            });
+            mergeTestDataInline(active, { [fieldKey]: value });
+            continue;
+        }
+        const clickMatch = line.match(/find_element\s*\(([^)]{0,240})\)\.click\(\s*\)/);
+        if (clickMatch) {
+            const locatorExpr = clickMatch[1];
+            const locator = locatorExpr.match(/["']([^"']+)["']\s*$/)?.[1] ?? locatorExpr;
+            const locatorHint = tryConvertXPathToSemantic(locator);
+            const label = locator.match(/text\(\)\s*=\s*["']([^"']+)["']/)?.[1]
+                ?? locator.match(/@(?:aria-label|id|name)\s*=\s*["']([^"']+)["']/)?.[1]
+                ?? `element ${active.steps.length + 1}`;
+            active.steps.push({
+                action: `Click ${label}`,
+                expected: 'Action completes successfully',
+                ...(locatorHint ? { comment: `locatorHint: ${locatorHint}` } : {}),
+            });
+            continue;
+        }
+        const assertMatch = line.match(/^assert\s+(.+)/);
+        if (assertMatch) {
+            active.steps.push({ action: `Verify ${assertMatch[1].slice(0, 180)}`, expected: 'Assertion passes' });
+        }
+    }
+    flush();
+    return { cases: cases.map(c => sanitizeParsedCase(c)).filter((c) => c !== null), errors: [] };
+}
+function parseSpecFile(content, filePath) {
+    if (filePath?.toLowerCase().endsWith('.py') || /\bdef\s+test_[A-Za-z0-9_]+\s*\(/.test(content) || /find_element\s*\(|from\s+selenium\b|import\s+pytest\b/.test(content)) {
+        return parsePythonSpecFile(content, filePath);
+    }
+    const cases = [];
+    const errors = [];
+    const describeStack = [];
+    const depthAtDescribe = [];
+    let braceDepth = 0;
+    // Infer a fallback section from file path (parent folder, stripped of test-dir markers)
+    const TEST_DIR_MARKERS = new Set(['tests', 'test', 'e2e', 'cypress', 'spec', 'specs', '__tests__', 'integration', 'unit', 'features']);
+    let fileSection;
+    if (filePath) {
+        const parts = filePath.split('/');
+        // Last part is the filename; strip test extension
+        const filename = (parts.pop() ?? '').replace(/\.(spec|test|cy)\.[jt]sx?$/, '');
+        // Walk backwards to find a meaningful non-marker folder
+        const folder = [...parts].reverse().find(p => !TEST_DIR_MARKERS.has(p.toLowerCase()));
+        fileSection = folder ?? filename;
+    }
+    for (const rawLine of content.split('\n')) {
+        const trimmed = rawLine.trim();
+        // Skip single-line comments
+        if (trimmed.startsWith('//') || trimmed.startsWith('*')) {
+            continue;
+        }
+        // Count net braces in line, skipping string contents
+        let lineOpen = 0, lineClose = 0;
+        let inStr = false, strChar = '';
+        for (const ch of rawLine) {
+            if (inStr) {
+                if (ch === strChar)
+                    inStr = false;
+            }
+            else if (ch === '"' || ch === "'" || ch === '`') {
+                inStr = true;
+                strChar = ch;
+            }
+            else if (ch === '{')
+                lineOpen++;
+            else if (ch === '}')
+                lineClose++;
+        }
+        braceDepth += lineOpen - lineClose;
+        // Pop finished describe blocks
+        while (depthAtDescribe.length > 0 && braceDepth < depthAtDescribe[depthAtDescribe.length - 1]) {
+            depthAtDescribe.pop();
+            describeStack.pop();
+        }
+        // describe / context / suite (including .only, .skip, .each)
+        const describeMatch = trimmed.match(/^(?:describe|context|suite)(?:\.only|\.skip|\.each\([^)]*\))?\s*\(\s*(["'`])(.*?)\1/);
+        if (describeMatch) {
+            describeStack.push(describeMatch[2]);
+            depthAtDescribe.push(braceDepth);
+            continue;
+        }
+        // it / test / specify (including .only, .skip, .each)
+        const testMatch = trimmed.match(/^(?:it|test|specify)(?:\.only|\.skip|\.each\([^)]*\))?\s*\(\s*(["'`])(.*?)\1/);
+        if (!testMatch)
+            continue;
+        const title = testMatch[2];
+        const section = describeStack.length > 0
+            ? describeStack[describeStack.length - 1]
+            : fileSection;
+        const outerTag = describeStack.length > 1 ? describeStack[0] : undefined;
+        cases.push({
+            title,
+            kind: 'E2E',
+            priority: 'MEDIUM',
+            section: section ?? undefined,
+            tags: outerTag ? [outerTag] : undefined,
+            steps: [{ action: `Execute: ${title}`, expected: 'Test passes without errors' }],
+            expectedResult: 'Test passes without errors',
+        });
+    }
+    return { cases, errors };
+}
+function parseGherkin(content) {
+    const cases = [];
+    const backgroundSteps = [];
+    let pendingTags = [];
+    let current = null;
+    let mode = 'none';
+    let inDocString = false;
+    let docStringChar = '';
+    let docStringContent = [];
+    const flush = () => {
+        if (current)
+            cases.push(...expandScenario(current, backgroundSteps));
+        current = null;
+        inDocString = false;
+    };
+    for (const rawLine of content.split('\n')) {
+        const line = rawLine.trim();
+        if (!line && !inDocString)
+            continue;
+        if (inDocString) {
+            if (line === docStringChar) {
+                inDocString = false;
+                if (current && current.stepLines.length > 0) {
+                    const lastStep = current.stepLines[current.stepLines.length - 1];
+                    lastStep.data = docStringContent.join('\n');
+                }
+            }
+            else {
+                docStringContent.push(rawLine); // keep original indent
+            }
+            if (current)
+                current.raw.push(rawLine);
+            continue;
+        }
+        if (line.startsWith('"""') || line.startsWith("'''")) {
+            inDocString = true;
+            docStringChar = line.slice(0, 3);
+            docStringContent = [];
+            if (current)
+                current.raw.push(rawLine);
+            continue;
+        }
+        if (/^@[\w-]/.test(line)) {
+            pendingTags.push(...(line.match(/@[\w-]+/g) ?? []));
+            continue;
+        }
+        if (/^Background:/.test(line)) {
+            flush();
+            mode = 'background';
+            pendingTags = [];
+            continue;
+        }
+        const scenMatch = line.match(/^(Scenario Outline|Scenario):\s*(.*)/);
+        if (scenMatch) {
+            flush();
+            current = {
+                title: scenMatch[2].trim(),
+                tags: pendingTags,
+                isOutline: scenMatch[1] === 'Scenario Outline',
+                stepLines: [],
+                exampleLines: [],
+                raw: [rawLine],
+            };
+            pendingTags = [];
+            mode = 'scenario';
+            continue;
+        }
+        if (/^Examples:/.test(line)) {
+            if (current) {
+                mode = 'examples';
+                current.raw.push(rawLine);
+            }
+            continue;
+        }
+        if (mode === 'background' && /^(Given|When|Then|And|But|\*)\s+/.test(line)) {
+            backgroundSteps.push(line);
+        }
+        else if (mode === 'scenario' && current && /^(Given|When|Then|And|But|\*)\s+/.test(line)) {
+            current.stepLines.push({ text: line });
+            current.raw.push(rawLine);
+        }
+        else if (mode === 'examples' && current && line.startsWith('|')) {
+            current.exampleLines.push(line);
+            current.raw.push(rawLine);
+        }
+        else if (mode === 'scenario' && current && line.startsWith('|')) {
+            // Step data table
+            if (current.stepLines.length > 0) {
+                const lastStep = current.stepLines[current.stepLines.length - 1];
+                lastStep.data = lastStep.data ? lastStep.data + '\n' + line : line;
+            }
+            current.raw.push(rawLine);
+        }
+        else if (current) {
+            current.raw.push(rawLine);
+        }
+    }
+    flush();
+    return { cases, errors: [] };
+}
+function buildGherkinSteps(stepLines) {
+    const steps = [];
+    let expectedResult = '';
+    let inThen = false;
+    for (const step of stepLines) {
+        if (/^Then\s/.test(step.text))
+            inThen = true;
+        else if (/^(Given|When)\s/.test(step.text))
+            inThen = false;
+        if (inThen) {
+            expectedResult = step.text.replace(/^(?:Then|And|But|\*)\s+/, '');
+            steps.push({ action: step.text, data: step.data, expected: expectedResult });
+        }
+        else {
+            steps.push({ action: step.text, data: step.data, expected: '' });
+        }
+    }
+    return { steps, expectedResult };
+}
+function expandScenario(sc, backgroundSteps) {
+    if (sc.stepLines.length === 0)
+        return [];
+    const gherkin = sc.raw.join('\n').trim();
+    const preconditions = backgroundSteps.length
+        ? backgroundSteps.map((s) => s.replace(/^(?:Given|And|But|\*)\s+/, '')).join('; ')
+        : undefined;
+    const make = (title, stepLines, testDataInline) => {
+        const { steps, expectedResult } = buildGherkinSteps(stepLines);
+        return {
+            title,
+            kind: 'POSITIVE',
+            priority: 'MEDIUM',
+            preconditions,
+            steps,
+            expectedResult: expectedResult || title,
+            gherkin,
+            tags: sc.tags,
+            ...(testDataInline && Object.keys(testDataInline).length > 0 ? { testDataInline } : {}),
+        };
+    };
+    // Expand Scenario Outline: one concrete case per Examples row
+    if (sc.isOutline && sc.exampleLines.length >= 2) {
+        const parseRow = (l) => l.split('|').slice(1, -1).map((c) => c.trim());
+        const header = parseRow(sc.exampleLines[0]);
+        return sc.exampleLines.slice(1).map((rowLine, i) => {
+            const row = parseRow(rowLine);
+            const substitute = (s) => header.reduce((acc, h, j) => acc.split(`<${h}>`).join(row[j] ?? ''), s);
+            const subSteps = sc.stepLines.map((s) => ({
+                text: substitute(s.text),
+                data: s.data ? substitute(s.data) : undefined,
+            }));
+            const rawExampleData = Object.fromEntries(header.map((h, j) => [h, row[j] ?? '']).filter(([, v]) => String(v).trim()));
+            const exampleData = parseImportedTestData(rawExampleData) ?? {};
+            return make(`${substitute(sc.title)} [example ${i + 1}]`, subSteps, exampleData);
+        });
+    }
+    return [make(sc.title, sc.stepLines)];
+}
+// ─── Tabular (Excel / CSV as markdown tables) ────────────────────────────────
+/**
+ * Extract headers and up to `maxSamples` data rows from the first sheet
+ * of a markdown-table artifact. Used by the /infer-mapping route.
+ */
+function extractTabularHeaders(content, maxSamples = 3) {
+    // Use first sheet section if multi-sheet
+    const firstSection = content.split(/^### Sheet:.*$/m)[1] ?? content;
+    const lines = firstSection.split('\n').filter(Boolean);
+    const headerIdx = lines.findIndex((l) => l.startsWith('|'));
+    if (headerIdx < 0)
+        return { headers: [], sampleRows: [] };
+    const rawHeaders = lines[headerIdx]
+        .split('|').slice(1, -1).map((h) => h.trim()).filter(Boolean);
+    const parseCells = (row) => row.split('|').map((c) => c.trim()).filter((_, i, a) => i > 0 && i < a.length - 1);
+    const sampleRows = lines
+        .slice(headerIdx + 2)
+        .filter((l) => l.startsWith('|') && !l.match(/^[\s|:-]+$/))
+        .slice(0, maxSamples)
+        .map(parseCells);
+    return { headers: rawHeaders, sampleRows };
+}
+function parseTabular(content, mapping, sourcePlatform) {
+    // A multi-sheet workbook produces one "### Sheet:" section per sheet,
+    // each with its own header row — parse each section independently.
+    const parts = content.split(/^### Sheet:\s*(.*)$/m);
+    const cases = [];
+    const errors = [];
+    // parts[0] is everything before the first "### Sheet:"
+    // If there are no sheets, parts = [content]
+    if (parts.length === 1) {
+        const res = parseTabularSection(parts[0], mapping, undefined, sourcePlatform);
+        return { cases: res.cases, errors: res.errors };
+    }
+    for (let i = 1; i < parts.length; i += 2) {
+        const sheetName = parts[i].trim();
+        const sheetContent = parts[i + 1] ?? '';
+        const res = parseTabularSection(sheetContent, mapping, sheetName, sourcePlatform);
+        cases.push(...res.cases);
+        errors.push(...res.errors);
+    }
+    return { cases, errors };
+}
+// StackLens row-per-step format: TC_Id # | TC Description | Test Data | Steps# | Test Steps | Expected Result …
+function parseStackLens(rawHeaders, dataRows, sourcePlatform) {
+    const parseCells = (row) => row.split('|').map(c => c.trim().replace(/\\\|/g, '|')).filter((_, i, a) => i > 0 && i < a.length - 1);
+    const h = rawHeaders.map(x => x.toLowerCase().replace(/[\s_#]+/g, ''));
+    const idxOf = (...keys) => {
+        const i = h.findIndex(x => keys.some(k => x.includes(k)));
+        return i >= 0 ? i : -1;
+    };
+    const tcIdCol = idxOf('tcid');
+    const descCol = idxOf('tcdescription', 'description');
+    const priorityCol = idxOf('priority', 'severity');
+    const kindCol = idxOf('type', 'kind', 'category');
+    const preconditionsCol = idxOf('preconditions', 'prerequisites');
+    const testDataCol = idxOf('testdata');
+    const _stepsNumCol = idxOf('steps#', 'stepsno', 'stepno');
+    const stepsCol = idxOf('teststep', 'steps');
+    const expectedCol = idxOf('expectedresult', 'expected');
+    const actualResultCol = idxOf('actualresult', 'actual');
+    const statusCol = idxOf('status', 'teststatus', 'runstatus', 'passfail');
+    const commentsCol = idxOf('comment', 'notes', 'remark', 'observation');
+    const screenshotCol = idxOf('screenshot', 'evidence', 'attachment');
+    const tagsCol = idxOf('tags', 'label', 'markers');
+    const sectionCol = idxOf('module', 'suite', 'section', 'folder', 'component');
+    const cases = [];
+    let current = null;
+    for (const row of dataRows) {
+        const cells = parseCells(row);
+        const tcId = tcIdCol >= 0 ? (cells[tcIdCol] ?? '') : '';
+        const desc = descCol >= 0 ? (cells[descCol] ?? '') : '';
+        const step = stepsCol >= 0 ? (cells[stepsCol] ?? '') : '';
+        const expected = expectedCol >= 0 ? (cells[expectedCol] ?? '') : '';
+        const testData = testDataCol >= 0 ? (cells[testDataCol] ?? '') : '';
+        const actualResult = actualResultCol >= 0 ? (cells[actualResultCol] ?? '') : '';
+        const status = statusCol >= 0 ? (cells[statusCol] ?? '') : '';
+        const comment = commentsCol >= 0 ? (cells[commentsCol] ?? '') : '';
+        const screenshotUrl = screenshotCol >= 0 ? (cells[screenshotCol] ?? '') : '';
+        const tagsRaw = tagsCol >= 0 ? (cells[tagsCol] ?? '') : '';
+        if (tcId) {
+            current = {
+                ref: normalizeRef(tcId, sourcePlatform),
+                title: desc || tcId,
+                kind: kindCol >= 0 ? normalizeKind(cells[kindCol] ?? '') : 'POSITIVE',
+                priority: priorityCol >= 0 ? ((0, core_1.normalizePriority)(cells[priorityCol] ?? '') ?? 'MEDIUM') : 'MEDIUM',
+                preconditions: preconditionsCol >= 0 ? (cells[preconditionsCol] || undefined) : (testData || undefined),
+                steps: [],
+                expectedResult: expected || desc || tcId,
+                actualResult: actualResult || undefined,
+                status: status || undefined,
+                comment: comment || undefined,
+                screenshotUrl: screenshotUrl || undefined,
+                tags: tagsRaw ? tagsRaw.split(/[,;|]/).map(t => t.trim()).filter(Boolean) : undefined,
+                section: sectionCol >= 0 ? (cells[sectionCol] || undefined) : undefined,
+            };
+            mergeTestDataInline(current, testData);
+            cases.push(current);
+        }
+        if (current && step) {
+            mergeTestDataInline(current, testData);
+            current.steps.push({
+                action: step,
+                data: testData || undefined,
+                expected: expected || '',
+                actualResult: actualResult || undefined,
+                comment: comment || undefined,
+                screenshotUrl: screenshotUrl || undefined,
+            });
+        }
+    }
+    return {
+        cases: cases.filter(c => c.title).map(c => ({
+            ...c,
+            steps: c.steps.length > 0 ? c.steps : [{ action: 'Execute test case', expected: c.expectedResult }],
+            expectedResult: c.expectedResult || c.title,
+        })),
+        errors: [],
+    };
+}
+function parseTabularSection(content, mapping, defaultSection, sourcePlatform) {
+    const cases = [];
+    const errors = [];
+    const lines = content.split('\n').filter(Boolean);
+    // Find header row
+    const headerIdx = lines.findIndex((l) => l.startsWith('|'));
+    if (headerIdx < 0)
+        return { cases, errors };
+    const rawHeaders = lines[headerIdx]
+        .split('|').slice(1, -1).map((h) => h.trim());
+    // Detect StackLens row-per-step format (TC_Id # column present)
+    if (rawHeaders.some(h => h.toLowerCase().replace(/[\s_#]+/g, '') === 'tcid')) {
+        const dataRows = lines.slice(headerIdx + 2).filter((l) => l.startsWith('|') && !l.match(/^[\s|:-]+$/));
+        return parseStackLens(rawHeaders, dataRows, sourcePlatform);
+    }
+    const dataRows = lines.slice(headerIdx + 2).filter((l) => l.startsWith('|') && !l.match(/^[\s|:-]+$/));
+    // Resolve column indices: use provided mapping when available, fall back to heuristic
+    const resolved = mapping ?? _heuristicMapping(rawHeaders);
+    const col = (field) => resolved[field] !== undefined ? resolved[field] : -1;
+    const titleCol = col('title');
+    const refCol = col('ref');
+    const stepsCol = col('steps');
+    const expectedCol = col('expected');
+    const priorityCol = col('priority');
+    const kindCol = col('kind');
+    const preconCol = col('preconditions');
+    const dataCol = col('data');
+    const tagsCol = col('tags');
+    const sectionCol = col('section');
+    const caseStartCol = col('caseStart');
+    const actualResultCol = col('actualResult');
+    const commentCol = col('comment');
+    const stepIdCol = col('stepId');
+    const screenshotUrlCol = col('screenshotUrl');
+    const statusCol = col('status');
+    if (titleCol < 0 && refCol < 0) {
+        errors.push(`Missing 'Title' or 'Ref' column mapping (Sheet: ${defaultSection ?? 'Default'})`);
+        return { cases, errors };
+    }
+    const parseCells = (row) => row.split('|').map((c) => c.trim().replace(/\\\|/g, '|')).filter((_, i, a) => i > 0 && i < a.length - 1);
+    let current = null;
+    let rowCount = 0;
+    for (const row of dataRows) {
+        rowCount++;
+        const cells = parseCells(row);
+        const title = titleCol >= 0 ? cells[titleCol] ?? '' : '';
+        const ref = refCol >= 0 ? cells[refCol] ?? '' : '';
+        const stepsRaw = stepsCol >= 0 ? cells[stepsCol] ?? '' : '';
+        const expected = expectedCol >= 0 ? cells[expectedCol] ?? '' : '';
+        const data = dataCol >= 0 ? cells[dataCol] ?? '' : '';
+        const tagsRaw = tagsCol >= 0 ? cells[tagsCol] ?? '' : '';
+        const sectionRaw = sectionCol >= 0 ? cells[sectionCol] ?? '' : '';
+        const actualResultRaw = actualResultCol >= 0 ? cells[actualResultCol] ?? '' : '';
+        const commentRaw = commentCol >= 0 ? cells[commentCol] ?? '' : '';
+        const stepIdRaw = stepIdCol >= 0 ? cells[stepIdCol] ?? '' : '';
+        const screenshotUrlRaw = screenshotUrlCol >= 0 ? cells[screenshotUrlCol] ?? '' : '';
+        let isNewCase = false;
+        if (caseStartCol >= 0) {
+            isNewCase = !!(cells[caseStartCol]?.trim());
+        }
+        else {
+            // Require at least some content alongside the ref — reject ID-only rows
+            isNewCase = !!(title || (ref && (stepsRaw || expected || data)));
+        }
+        if (isNewCase || (!current && (title || (ref && (stepsRaw || expected || data))))) {
+            const tags = tagsRaw ? tagsRaw.split(/[,;|]/).map((t) => t.trim()).filter(Boolean) : undefined;
+            const section = sectionRaw || defaultSection;
+            current = {
+                ref: ref ? normalizeRef(ref, sourcePlatform) : undefined,
+                title: title || ref,
+                kind: kindCol >= 0 ? normalizeKind(cells[kindCol] ?? '') : 'POSITIVE',
+                priority: priorityCol >= 0 ? ((0, core_1.normalizePriority)(cells[priorityCol] ?? '') ?? 'MEDIUM') : 'MEDIUM',
+                preconditions: preconCol >= 0 ? (cells[preconCol] || undefined) : undefined,
+                steps: [],
+                expectedResult: expected || title || ref,
+                actualResult: actualResultRaw || undefined,
+                comment: commentRaw || undefined,
+                screenshotUrl: screenshotUrlRaw || undefined,
+                status: statusCol >= 0 ? (cells[statusCol] ?? undefined) : undefined,
+                tags,
+                section,
+            };
+            mergeTestDataInline(current, data);
+            cases.push(current);
+        }
+        if (!current) {
+            if (stepsRaw || expected) {
+                errors.push(`Row ${rowCount} (Sheet: ${defaultSection ?? 'Default'}): Step data ignored because it lacks a title/ref to start a test case.`);
+            }
+            continue;
+        }
+        if (stepsRaw) {
+            mergeTestDataInline(current, data);
+            // Split on newlines, semicolons, or "1. " / "1) " numbering — the marker
+            // requires trailing whitespace so decimals like "1.5" stay intact.
+            const stepList = stepsRaw.split(/\n|;|\s*\d+[.)]\s+/).map((s) => s.trim()).filter(Boolean);
+            for (let si = 0; si < stepList.length; si++) {
+                const s = stepList[si];
+                const derivedStepId = stepIdRaw || (stepList.length > 1 ? String(si + 1) : undefined);
+                current.steps.push({
+                    stepId: derivedStepId,
+                    action: s,
+                    data: data || undefined,
+                    expected: expected || '',
+                    actualResult: actualResultRaw || undefined,
+                    comment: commentRaw || undefined,
+                    screenshotUrl: screenshotUrlRaw || undefined,
+                });
+            }
+        }
+        else if (expected && !current.expectedResult) {
+            current.expectedResult = expected;
+        }
+        else if (expected && current.steps.length > 0) {
+            current.steps[current.steps.length - 1].expected = expected;
+        }
+    }
+    const finalCases = cases
+        .filter((c) => c.title)
+        .map((c) => ({
+        ...c,
+        steps: c.steps.length > 0 ? c.steps : [{ action: 'Execute test case', expected: c.expectedResult }],
+        expectedResult: c.expectedResult || c.title,
+    }));
+    return { cases: finalCases, errors };
+}
+// ─── AI extraction ───────────────────────────────────────────────────────────
+const AI_TARGET_CHUNK_SIZE = 10000;
+const AI_MAX_CHUNK_SIZE = 15000;
+const AI_MAX_CHUNKS = 15;
+function chunkContent(content) {
+    if (content.length <= 12000)
+        return [content];
+    // Try section-based chunking on headings (#, ##, ###, or 1. Section, or Section 1)
+    const lines = content.split(/\r?\n/);
+    const sections = [];
+    let curLines = [];
+    let curHeading = 'Introduction';
+    for (const line of lines) {
+        const isHeading = /^#{1,4}\s+[A-Za-z0-9]/.test(line) ||
+            /^(?:Section\s+\d+|\d+\.\s+[A-Z])/.test(line) ||
+            /^[A-Z][A-Za-z0-9 &/_().:-]{3,60}:$/m.test(line);
+        if (isHeading && curLines.length > 0) {
+            sections.push({ heading: curHeading, text: curLines.join('\n') });
+            curLines = [line];
+            curHeading = line.replace(/^#{1,4}\s+/, '').trim().slice(0, 80);
+        }
+        else {
+            curLines.push(line);
+        }
+    }
+    if (curLines.length > 0) {
+        sections.push({ heading: curHeading, text: curLines.join('\n') });
+    }
+    // Combine sections into chunks targetting 8k-12k characters
+    const chunks = [];
+    let currentChunk = '';
+    for (const sec of sections) {
+        // If a single section is itself massive (> AI_MAX_CHUNK_SIZE), split it by paragraphs or table blocks
+        if (sec.text.length > AI_MAX_CHUNK_SIZE) {
+            if (currentChunk.trim()) {
+                chunks.push(currentChunk.trim());
+                currentChunk = '';
+            }
+            let subPos = 0;
+            while (subPos < sec.text.length && chunks.length < AI_MAX_CHUNKS) {
+                let subEnd = Math.min(subPos + AI_TARGET_CHUNK_SIZE, sec.text.length);
+                if (subEnd < sec.text.length) {
+                    const nl = sec.text.lastIndexOf('\n\n', subEnd);
+                    if (nl > subPos + AI_TARGET_CHUNK_SIZE / 2)
+                        subEnd = nl;
+                }
+                chunks.push(sec.text.slice(subPos, subEnd).trim());
+                subPos = subEnd;
+            }
+            continue;
+        }
+        if (!currentChunk) {
+            currentChunk = sec.text;
+        }
+        else if (currentChunk.length + sec.text.length <= AI_MAX_CHUNK_SIZE) {
+            currentChunk += '\n\n' + sec.text;
+        }
+        else {
+            chunks.push(currentChunk.trim());
+            currentChunk = sec.text;
+            if (chunks.length >= AI_MAX_CHUNKS - 1)
+                break;
+        }
+    }
+    if (currentChunk.trim() && chunks.length < AI_MAX_CHUNKS) {
+        chunks.push(currentChunk.trim());
+    }
+    // Fallback: If section detection produced fewer than 2 chunks on a large doc, fall back to sliding window
+    if (chunks.length <= 1 && content.length > 16000) {
+        chunks.length = 0;
+        let pos = 0;
+        while (pos < content.length && chunks.length < AI_MAX_CHUNKS) {
+            let end = Math.min(pos + AI_TARGET_CHUNK_SIZE, content.length);
+            if (end < content.length) {
+                const nl = content.lastIndexOf('\n', end);
+                if (nl > pos + AI_TARGET_CHUNK_SIZE / 2)
+                    end = nl;
+            }
+            chunks.push(content.slice(pos, end).trim());
+            pos = end;
+        }
+    }
+    return chunks.filter(c => c.length > 50);
+}
+const AI_SCENARIO_SCHEMA = {
+    type: 'object',
+    properties: {
+        cases: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string', description: 'Verb-first descriptive title (e.g. "Verify payment total after coupon"). Max 120 chars.', maxLength: 120 },
+                    kind: { type: 'string', enum: ['POSITIVE', 'NEGATIVE', 'EDGE'] },
+                    priority: { type: 'string', enum: ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW'] },
+                    preconditions: { type: ['string', 'null'] },
+                    steps: {
+                        type: 'array',
+                        description: 'Actionable sequential steps (4 to 8 steps). Include setup/role, specific field inputs/values, action trigger, and precise expected assertion.',
+                        minItems: 4,
+                        items: {
+                            type: 'object',
+                            properties: {
+                                action: { type: 'string', description: 'Concrete tester action with field names, values, or UI buttons.' },
+                                expected: { type: 'string', description: 'Observable system reaction, state change, or verification.' },
+                            },
+                            required: ['action', 'expected'],
+                        },
+                    },
+                    expectedResult: { type: 'string' },
+                    tags: { type: 'array', items: { type: 'string' } },
+                    traceTo: { type: 'string', description: 'Source requirement or business-rule ID such as FR006, NFR002, or BR-VSA-ACCEPTANCE when provided.' },
+                    caseRefs: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                type: { type: 'string' },
+                                key: { type: 'string' },
+                                sourceSection: { type: 'string' },
+                                sourceExcerpt: { type: 'string' },
+                            },
+                        },
+                    },
+                },
+                required: ['title', 'kind', 'priority', 'steps'],
+            },
+        },
+    },
+    required: ['cases'],
+};
+const AI_SCENARIO_SYSTEM = `You are a senior QA analyst generating test cases for a specific scenario.
+Rules:
+- Generate EXACTLY the requested number of distinct, varied test cases.
+- "kind" MUST be one of exactly three values: POSITIVE, NEGATIVE, or EDGE. No other values are allowed.
+  - POSITIVE: happy path, expected successful behavior
+  - NEGATIVE: error conditions, invalid input, rejection, failure handling
+  - EDGE: boundary values, concurrent access, timeout, partial failure, rollback
+- Case mix: when generating 3 or more cases, include at least 1 POSITIVE, 1 NEGATIVE, and 1 EDGE. For 1-2 cases, choose the highest-risk kind(s) for the source requirement.
+- "priority": CRITICAL/HIGH/MEDIUM/LOW
+- Each test case MUST have the number of steps needed to execute the behavior clearly, usually 3–10. Do not pad to a fixed count.
+  Steps SHOULD cover these phases when relevant: (1) prerequisite/navigation setup, (2) initial state verification, (3) data entry or configuration input, (4) primary action trigger, (5+) one step per distinct acceptance criterion or verifiable outcome.
+- Every step must have a concrete action AND expected result — never leave either blank.
+- Do NOT collapse multiple behaviors or outcomes into one step. Each distinct verifiable condition = its own step.
+- For NEGATIVE test cases: add steps for attempting the invalid action, observing the specific error/rejection message, and verifying the system recovers to a valid state.
+- Do NOT duplicate test cases — each must test a distinct behavior.
+- If the scenario includes Requirement, Source Section, Category, or Source Excerpt metadata, preserve it in traceTo/caseRefs and use it to keep the case grounded.`;
+function parseScenarioCount(ctx) {
+    const m = ctx.match(/\(generate\s+(\d+)\s+distinct test cases\)/i)
+        ?? ctx.match(/(?:suggested|generate|count)\D{0,20}(\d{1,2})\s+test/i);
+    return m ? Math.max(1, Math.min(20, parseInt(m[1], 10))) : 3;
+}
+function parseScenarioContextMeta(scenarioCtx) {
+    const firstLine = scenarioCtx.split(/\r?\n/)[0] ?? '';
+    const title = firstLine.replace(/\s*\(generate\s+\d+\s+distinct test cases\)\s*/i, '').split(':')[0].trim();
+    const field = (name) => {
+        const re = new RegExp(`^${name}:\\s*(.+)$`, 'im');
+        return scenarioCtx.match(re)?.[1]?.trim();
+    };
+    const traceTo = field('Requirement') ?? field('Trace') ?? field('Rule');
+    const sourceSection = field('Source Section');
+    const sourceExcerpt = field('Source Excerpt');
+    const category = field('Category');
+    const caseRefs = traceTo ? [{
+            type: traceTo.startsWith('BR-') ? 'BRD_BUSINESS_RULE' : 'BRD_REQUIREMENT',
+            key: traceTo,
+            ...(sourceSection ? { sourceSection } : {}),
+            ...(sourceExcerpt ? { sourceExcerpt } : {}),
+            ...(category ? { category } : {}),
+        }] : undefined;
+    return { title, traceTo, sourceSection, sourceExcerpt, category, caseRefs };
+}
+function supplementalScenarioCase(scenarioCtx, index) {
+    const meta = parseScenarioContextMeta(scenarioCtx);
+    const titleBase = meta.title || 'Selected scenario';
+    const kinds = ['POSITIVE', 'NEGATIVE', 'EDGE'];
+    const kind = kinds[index % kinds.length];
+    return {
+        traceTo: meta.traceTo,
+        caseRefs: meta.caseRefs,
+        title: `${titleBase} - ${kind.toLowerCase()} path ${index + 1}`,
+        kind,
+        priority: index === 0 ? 'HIGH' : 'MEDIUM',
+        preconditions: `Scenario context: ${scenarioCtx.slice(0, 240)}`,
+        steps: [
+            { action: `Navigate to the workflow for "${titleBase}".`, expected: 'The relevant application workflow is displayed.' },
+            { action: `Exercise the ${kind.toLowerCase()} behavior described by the selected scenario.`, expected: 'The behavior remains aligned with the selected scenario.' },
+            { action: 'Verify the final observable result.', expected: 'The result matches the selected scenario and does not introduce unrelated content.' },
+        ],
+        expectedResult: `The ${kind.toLowerCase()} path for "${titleBase}" is covered.`,
+        tags: ['@scenario-import', `@${kind.toLowerCase()}`],
+    };
+}
+function enforceScenarioCaseCount(cases, scenarioCtx, count) {
+    const exact = cases.slice(0, count);
+    const seen = new Set(exact.map((tc) => tc.title.toLowerCase().trim()));
+    let i = 0;
+    while (exact.length < count) {
+        const supplemental = supplementalScenarioCase(scenarioCtx, i);
+        if (!seen.has(supplemental.title.toLowerCase().trim())) {
+            exact.push(supplemental);
+            seen.add(supplemental.title.toLowerCase().trim());
+        }
+        i += 1;
+    }
+    return exact;
+}
+/** Stable cache key from a scenario context string — strips count hint, normalises. */
+function scenarioContextKey(ctx) {
+    return ctx
+        .replace(/\s*\(generate\s+\d+\s+distinct test cases\)\s*/gi, '')
+        .split(':')[0]
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '')
+        .trim()
+        .slice(0, 80);
+}
+function coerceKind(tc) {
+    if (!['POSITIVE', 'NEGATIVE', 'EDGE'].includes(tc.kind)) {
+        const k = tc.kind.toUpperCase();
+        if (['STATE_TRANSITION', 'E2E', 'INTEGRATION', 'API', 'SMOKE', 'SANITY', 'REGRESSION', 'UAT'].includes(k)) {
+            tc.kind = 'POSITIVE';
+        }
+        else if (['SECURITY', 'ACCESSIBILITY', 'EXPLORATORY', 'USABILITY', 'UNIT', 'MUTATION', 'L10N', 'COMPATIBILITY'].includes(k)) {
+            tc.kind = 'NEGATIVE';
+        }
+        else {
+            tc.kind = 'EDGE';
+        }
+    }
+}
+async function extractPerScenario(content, llmCfg, scenarioContext, tenantId) {
+    const effectiveScenarioSystem = await (0, core_1.getAgentPrompt)('test-import-scenario', undefined, tenantId) ?? AI_SCENARIO_SYSTEM;
+    const isContentMinimal = content.trim().length < 300;
+    const docRef = !isContentMinimal
+        ? `\n\nReference document:\n${content.length > 16000 ? content.slice(0, 16000) + '\n… (truncated)' : content}`
+        : '';
+    const allCases = [];
+    const byScenario = {};
+    const seenTitles = new Set();
+    const errors = [];
+    await Promise.all(scenarioContext.map(async (scenarioCtx) => {
+        const cacheKey = scenarioContextKey(scenarioCtx);
+        const count = parseScenarioCount(scenarioCtx);
+        const meta = parseScenarioContextMeta(scenarioCtx);
+        const grounding = [
+            meta.traceTo ? `Requirement: ${meta.traceTo}` : '',
+            meta.sourceSection ? `Source Section: ${meta.sourceSection}` : '',
+            meta.category ? `Category: ${meta.category}` : '',
+            meta.sourceExcerpt ? `Source Excerpt: ${meta.sourceExcerpt}` : '',
+        ].filter(Boolean).join('\n');
+        const user = `Generate exactly ${count} distinct test cases for this scenario. Preserve any source metadata in traceTo/caseRefs:\n${scenarioCtx}${grounding ? `\n\nGrounding metadata:\n${grounding}` : ''}${docRef}`;
+        try {
+            const seed = (0, llm_js_1.deterministicSeed)(`${scenarioCtx}:${count}`);
+            const { text } = await (0, llm_js_1.askTracked)(effectiveScenarioSystem, user, llmCfg, 4096, AI_SCENARIO_SCHEMA, { temperature: 0, seed });
+            const parsed = JSON.parse(text);
+            const scenarioCases = [];
+            for (const raw of (parsed.cases ?? [])) {
+                const tc = sanitizeParsedCase(raw);
+                if (!tc)
+                    continue;
+                if (meta.traceTo && !tc.traceTo)
+                    tc.traceTo = meta.traceTo;
+                if (meta.caseRefs && !tc.caseRefs?.length)
+                    tc.caseRefs = meta.caseRefs;
+                const metaTags = [meta.traceTo, meta.category]
+                    .filter(Boolean)
+                    .map((t) => `@${String(t).toLowerCase().replace(/[^a-z0-9]+/g, '-')}`);
+                tc.tags = [...new Set([...(tc.tags ?? []), ...metaTags])];
+                coerceKind(tc);
+                scenarioCases.push(tc);
+            }
+            const finalCases = enforceScenarioCaseCount(scenarioCases, scenarioCtx, count);
+            byScenario[cacheKey] = finalCases;
+            for (const tc of finalCases) {
+                const key = tc.title.toLowerCase().trim();
+                if (!seenTitles.has(key)) {
+                    seenTitles.add(key);
+                    allCases.push(tc);
+                }
+            }
+        }
+        catch (e) {
+            const label = scenarioCtx.replace(/\s*\(generate \d+ distinct test cases\)\s*/, '').split(':')[0].trim();
+            errors.push(`"${label}": ${e?.message ?? String(e)}`);
+            byScenario[cacheKey] = [];
+        }
+    }));
+    return { cases: allCases, byScenario, errors };
+}
+/**
+ * Cache-aware scenario test case generator.
+ * Returns cached cases for previously generated scenarios and only calls LLM for new ones.
+ * `existingCaseCache` is the `scenarioCases` map from `cachedScenarios` in DB.
+ * Returns merged cases + `updatedCache` to persist back.
+ */
+async function parseTestCasesWithCache(content, tenantId, scenarioContext, existingCaseCache) {
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(tenantId, 'appBrain').catch(() => null);
+    if (!llmCfg)
+        throw new Error('No LLM provider configured. Please set up an AI model in Workspace → Settings → AI Model before importing.');
+    const cachedCases = [];
+    const uncachedContexts = [];
+    for (const ctx of scenarioContext) {
+        const key = scenarioContextKey(ctx);
+        const hit = existingCaseCache[key];
+        if (hit?.length > 0) {
+            // Re-sanitize cached cases (schema may have changed)
+            const resanitized = hit.map(sanitizeParsedCase).filter((c) => c !== null);
+            resanitized.forEach(coerceKind);
+            cachedCases.push(...resanitized);
+        }
+        else {
+            uncachedContexts.push(ctx);
+        }
+    }
+    if (uncachedContexts.length === 0) {
+        return { cases: cachedCases, errors: [], updatedCache: existingCaseCache };
+    }
+    const { cases: newCases, byScenario, errors } = await extractPerScenario(content, llmCfg, uncachedContexts, tenantId);
+    const updatedCache = { ...existingCaseCache, ...byScenario };
+    return { cases: [...cachedCases, ...newCases], errors, updatedCache };
+}
+async function aiExtract(content, tenantId, scenarioContext) {
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(tenantId, 'appBrain').catch(() => null);
+    if (!llmCfg)
+        throw new Error('No LLM provider configured. Please set up an AI model in Workspace → Settings → AI Model before importing.');
+    // Per-scenario parallel extraction — each scenario gets its own focused LLM call for accurate counts
+    if (scenarioContext?.length) {
+        const { cases, errors } = await extractPerScenario(content, llmCfg, scenarioContext, tenantId);
+        return { cases, errors };
+    }
+    const AI_EXTRACTION_DEFAULT = `You are a senior QA analyst. Your job is to extract or derive detailed, executable test cases from any document.
+
+If the document already contains test cases (e.g. a test plan, test case sheet, feature file), extract them directly.
+If the document contains requirements, user stories, acceptance criteria, or specifications, DERIVE appropriate test cases from them.
+If the document is a spreadsheet with rows that represent scenarios or behaviors, treat each row as a test case.
+
+EXHAUSTIVENESS REQUIREMENT — READ CAREFULLY:
+Extract or derive a test case for EVERY distinct user story, requirement, acceptance criterion, business rule, and workflow mentioned in this document chunk. Do NOT stop early or summarise — cover them all. If a requirement has multiple validation rules, generate one test case per validation rule. If a user story has multiple acceptance criteria, generate one test case per criterion. A 10-requirement chunk should produce at least 10 test cases (typically more: positive + negative per requirement = 20+). Coverage over brevity.
+
+Rules:
+- "kind" MUST be one of exactly three values: POSITIVE, NEGATIVE, or EDGE. No other values are allowed.
+  - POSITIVE: happy-path functional test — verifies expected successful behavior (including security controls, performance checks, usability verifications that confirm the system works correctly)
+  - NEGATIVE: error/rejection/invalid-input test — verifies the system rejects bad input, enforces access control, or handles failure states correctly
+  - EDGE: boundary/limit/unusual-condition test — verifies behavior at data limits, concurrent access, timeout scenarios, rollback conditions
+- "priority" must be one of: CRITICAL, HIGH, MEDIUM, LOW
+- STEP DEPTH AND SPECIFICITY MANDATE:
+  - NEVER generate 1-step tests or superficial 3-step boilerplate (such as "Log in -> Logged in", "Navigate -> Displayed", "Perform action -> Completed").
+  - NEVER use terminology, role names, system names, or workflows from domains other than the document being processed. Steps must use only the actors, field names, system names, and business rules found in the source document.
+  - Each test case MUST have 4 to 8 sequential, executable steps:
+    1. Prerequisites / Setup: specific actor role (derived from the document) and initial navigation path.
+    2. Data Entry & Configuration: specific field names and concrete test data values taken from the source document's business rules, validation tables, and examples.
+    3. Trigger Action: the specific form submission, button click, or system action described in the source.
+    4. Immediate State / UI Feedback: field validation outcome, error message, or calculated result as described in the source.
+    5. System / Database Confirmation: booking reference, order ID, status update, or audit entry as described in the source.
+  - For validation rules & business tables:
+    Wrap each rule into an end-to-end execution workflow (Setup -> Enter boundary/invalid input in the named field -> Trigger -> Verify the specific rejection or error described in the source -> Recover).
+- FEATURE CATALOG & SUMMARY TABLE MANDATE — READ CAREFULLY:
+  - If the document contains summary or catalog tables defining Functional Features, User Roles, Permissions, or Reports:
+    - You MUST generate dedicated POSITIVE, NEGATIVE, and EDGE test cases for EVERY feature and role listed in those tables!
+    - Do NOT restrict test generation only to sections that contain narrative procedural steps. If a feature is listed in a summary table, derive full executable test cases verifying that feature's business purpose, required inputs, and failure modes using only terminology from the source document.
+- Extract preconditions stated in the document as the "preconditions" field — do not include them as steps.
+- If the document covers multiple distinct features, modules, or sections, set the "section" field to the feature/module name on each test case. This enables feature-wise suite organisation. If all cases belong to one feature, omit section.
+- When the document has explicit requirement IDs (FR001, NFR002) or named business rules, include "traceTo" and "caseRefs" so saved cases can be traced back to the source.
+- If you cannot derive any meaningful test cases, return an empty array []`;
+    const system = await (0, core_1.getAgentPrompt)('test-import-extraction', undefined, tenantId) ?? AI_EXTRACTION_DEFAULT;
+    const schema = {
+        type: 'object',
+        properties: {
+            cases: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string', description: 'Short descriptive title — verb-first, feature-scoped (e.g. "Verify checkout total after coupon"). Max 120 chars.', maxLength: 120 },
+                        kind: { type: 'string', enum: ['POSITIVE', 'NEGATIVE', 'EDGE'] },
+                        priority: { type: 'string', enum: ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW'] },
+                        preconditions: { type: ['string', 'null'] },
+                        steps: {
+                            type: 'array',
+                            description: 'Actionable sequential test steps (4 to 8 steps). Include operator role setup, specific field inputs with realistic test data values, action trigger, and precise observable expected outcomes. Both action and expected are required and non-empty.',
+                            minItems: 4,
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    action: { type: 'string', description: 'Specific tester action with named fields, UI buttons, or test values.' },
+                                    expected: { type: 'string', description: 'Concrete observable result — what the tester sees/verifies.' }
+                                },
+                                required: ['action', 'expected']
+                            }
+                        },
+                        expectedResult: { type: 'string' },
+                        tags: { type: 'array', items: { type: 'string' } },
+                        section: { type: 'string', description: 'Feature or module name — set when document covers multiple features to enable feature-wise suite grouping.' },
+                        traceTo: { type: 'string', description: 'Source requirement or business-rule ID such as FR006, NFR002, or BR-VSA-ACCEPTANCE when identifiable.' },
+                        caseRefs: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    type: { type: 'string' },
+                                    key: { type: 'string' },
+                                    sourceSection: { type: 'string' },
+                                    sourceExcerpt: { type: 'string' },
+                                },
+                            },
+                        }
+                    },
+                    required: ['title', 'kind', 'priority', 'steps']
+                }
+            }
+        },
+        required: ['cases']
+    };
+    const chunks = chunkContent(content);
+    const merged = [];
+    const seenTitles = new Set();
+    const errors = [];
+    let firstError = null;
+    for (let i = 0; i < chunks.length; i++) {
+        const part = chunks.length > 1 ? ` (part ${i + 1} of ${chunks.length})` : '';
+        const user = `Extract or derive test cases from this document${part}:\n\n${chunks[i]}`;
+        try {
+            const seed = (0, llm_js_1.deterministicSeed)(`extract:${i}:${chunks[i].slice(0, 300)}`);
+            const { text } = await (0, llm_js_1.askTracked)(system, user, llmCfg, 16384, schema, { temperature: 0, seed });
+            const parsed = JSON.parse(text);
+            const rawCases = parsed.cases || [];
+            for (const raw of rawCases) {
+                const tc = sanitizeParsedCase(raw);
+                if (!tc)
+                    continue;
+                const key = tc.title.toLowerCase();
+                if (seenTitles.has(key))
+                    continue;
+                seenTitles.add(key);
+                merged.push(tc);
+            }
+        }
+        catch (err) {
+            const msg = `AI extraction failed (part ${i + 1}): ${err?.message ?? String(err)}`;
+            errors.push(msg);
+            firstError = firstError ?? new Error(msg);
+        }
+    }
+    // Surface the error only when nothing was extracted at all
+    if (merged.length === 0 && firstError)
+        throw firstError;
+    return { cases: merged, errors };
+}
+const VALID_KINDS = new Set(['POSITIVE', 'NEGATIVE', 'EDGE', 'STATE_TRANSITION', 'ACCESSIBILITY', 'SECURITY', 'INTEGRATION', 'E2E', 'API', 'EXPLORATORY', 'UAT', 'PERFORMANCE', 'COMPATIBILITY', 'L10N', 'USABILITY', 'LOAD', 'UNIT', 'MUTATION', 'AB_TEST', 'ALPHA_BETA', 'SYSTEM', 'SMOKE', 'REGRESSION', 'SANITY']);
+function normalizeKind(raw) {
+    const r = raw.trim().toUpperCase().replace(/[-\s]+/g, '_');
+    if (VALID_KINDS.has(r))
+        return r;
+    if (r.includes('SECURITY') || r.includes('SEC'))
+        return 'SECURITY';
+    if (r.includes('ACCESS') || r.includes('A11Y'))
+        return 'ACCESSIBILITY';
+    if (r.includes('PERF'))
+        return 'PERFORMANCE';
+    if (r.includes('NEG') || r.includes('INVALID') || r.includes('ERROR') || r.includes('FAIL'))
+        return 'NEGATIVE';
+    if (r.includes('EDGE') || r.includes('BOUND') || r.includes('LIMIT'))
+        return 'EDGE';
+    if (r.includes('SMOK'))
+        return 'SMOKE';
+    if (r.includes('REGRESS'))
+        return 'REGRESSION';
+    if (r.includes('SANIT'))
+        return 'SANITY';
+    if (r.includes('E2E') || r.includes('END.TO.END') || r.includes('END_TO_END'))
+        return 'E2E';
+    if (r.includes('INTEGRAT'))
+        return 'INTEGRATION';
+    if (r.includes('API') || r.includes('CONTRACT'))
+        return 'API';
+    if (r.includes('UAT') || r.includes('ACCEPTANCE'))
+        return 'UAT';
+    if (r.includes('LOAD') || r.includes('STRESS'))
+        return 'LOAD';
+    if (r.includes('COMPAT'))
+        return 'COMPATIBILITY';
+    if (r.includes('UNIT'))
+        return 'UNIT';
+    // FUNCTIONAL / HAPPY PATH / POSITIVE → POSITIVE
+    return 'POSITIVE';
+}
+// ─── Functionize / FZE recording-format parser ───────────────────────────────
+// Handles the key→value JSON format emitted by Functionize (FZE) and similar
+// browser test recorders. Supports 50+ key prefixes covering navigation, form
+// inputs, dropdowns, checkboxes, radio buttons, assertions, custom JavaScript,
+// context/iframe switches, conditional branching, and ASP.NET ctl* controls.
+//
+// JSON repair is applied before parsing because the FZE exporter emits literal
+// newlines and unescaped double-quotes inside JavaScript code values, making the
+// output invalid JSON. Three-pass repair: (1) state-machine newline escape,
+// (2) standard JSON.parse, (3) line-based raw extractor for stubborn files.
+//
+// Paired field convention used by the recorder:
+//   "szField": ""          → current/blank value   (SKIP — sibling _1 has target)
+//   "szField_1": "Value"   → value to type/select  (EMIT step)
+// Same pattern applies to list*, txt*, inputInput*, reason*, typeaheaddropdown*.
+// ── JSON repair utilities ─────────────────────────────────────────────────────
+/** State-machine pass: escape literal \n and \r inside JSON string values. */
+function repairJsonStringLiterals(raw) {
+    let out = '';
+    let inStr = false;
+    let esc = false;
+    for (let i = 0; i < raw.length; i++) {
+        const c = raw[i];
+        if (esc) {
+            out += c;
+            esc = false;
+            continue;
+        }
+        if (c === '\\') {
+            esc = true;
+            out += c;
+            continue;
+        }
+        if (c === '"') {
+            inStr = !inStr;
+            out += c;
+            continue;
+        }
+        if (inStr && c === '\n') {
+            out += '\\n';
+            continue;
+        }
+        if (inStr && c === '\r') {
+            out += '\\r';
+            continue;
+        }
+        out += c;
+    }
+    return out;
+}
+/**
+ * Standard JSON.parse, falling back to repairJsonStringLiterals() on failure
+ * (Passes 1+2 of tryParseJsonCases's 3-pass chain below). Exported so other
+ * routes that parse the same real-world-messy FZE JSON exports — e.g.
+ * packages/api/src/routes/functionize.ts, which previously did a bare
+ * JSON.parse with no fallback and would throw on the exact literal-newline/
+ * unescaped-quote files this repairs — don't need their own copy of this
+ * logic. Pass 3 (extractFzeRawPairs + parseFunctionizeCases) is intentionally
+ * NOT included here: it returns ParsedTestCase[], a different shape than
+ * functionize.ts's own per-key step decoder expects, so wiring it in would
+ * need a larger rewrite of that route's data flow — left as a follow-up.
+ * See docs/101-GAPS-FUNCTIONIZE-MIGRATION-PIPELINE.md §3.1.
+ */
+function parseJsonWithRepair(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return JSON.parse(repairJsonStringLiterals(raw));
+    }
+}
+/**
+ * Line-based raw pair extractor — last-resort fallback for files with unescaped
+ * interior double-quotes inside code/conditional values (e.g. `"qa"` inside a
+ * string). Parses the FZE structure directly without relying on JSON.parse.
+ * Returns one Record<string,string> per JSON object found in the input.
+ */
+function extractFzeRawPairs(content) {
+    const lines = content.split('\n').map((l) => l.replace(/\r$/, ''));
+    const allObjects = [];
+    let currentObj = null;
+    let currentKey = null;
+    let currentValueLines = [];
+    const flushValue = () => {
+        if (currentKey !== null && currentObj !== null) {
+            if (currentValueLines.length > 0) {
+                currentValueLines[currentValueLines.length - 1] =
+                    currentValueLines[currentValueLines.length - 1].replace(/",?\s*$/, '');
+            }
+            currentObj[currentKey] = currentValueLines.join('\n');
+        }
+        currentKey = null;
+        currentValueLines = [];
+    };
+    const isNewKeyLine = (l) => /^\s*"[^"]+"\s*:/.test(l);
+    const isStructural = (t) => t === '[' || t === ']' || t === '{' || t === '}' || t === '},' || t === '},';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        const nextTrimmed = (lines[i + 1] ?? '').trim();
+        if (isStructural(trimmed)) {
+            flushValue();
+            if (trimmed === '{') {
+                currentObj = {};
+                allObjects.push(currentObj);
+            }
+            continue;
+        }
+        // Compact bracket+brace forms: "[{", "[ {", "},{", "}, {" on the same line.
+        // Functionize exports sometimes omit the newline between "[" and "{".
+        if (/^\[\s*\{$/.test(trimmed) || /^\}\s*,\s*\{$/.test(trimmed)) {
+            flushValue();
+            currentObj = {};
+            allObjects.push(currentObj);
+            continue;
+        }
+        const kvMatch = line.match(/^\s*"([^"]+)":\s*"(.*)/);
+        if (kvMatch && currentObj !== null) {
+            flushValue();
+            currentKey = kvMatch[1];
+            const rest = kvMatch[2];
+            const nextIsContext = isNewKeyLine(nextTrimmed) || isStructural(nextTrimmed);
+            if (nextIsContext || /",?\s*$/.test(rest)) {
+                currentObj[currentKey] = rest.replace(/",?\s*$/, '');
+                currentKey = null;
+                currentValueLines = [];
+            }
+            else {
+                currentValueLines = [rest];
+            }
+            continue;
+        }
+        if (currentKey !== null && currentObj !== null) {
+            const nextIsContext = isNewKeyLine(nextTrimmed) || isStructural(nextTrimmed);
+            if (nextIsContext) {
+                currentValueLines.push(line.replace(/",?\s*$/, ''));
+                flushValue();
+            }
+            else {
+                currentValueLines.push(line);
+            }
+        }
+    }
+    flushValue();
+    return allObjects.filter((o) => Object.keys(o).length > 0);
+}
+// ── Format detection ──────────────────────────────────────────────────────────
+/**
+ * Detect Functionize / FZE recording format — a JSON array of flat key→value
+ * maps representing a recorded browser session. Matches on the most distinctive
+ * key patterns present across all known FZE file variants.
+ */
+function isFunctionizeFormat(arr) {
+    if (!arr.length)
+        return false;
+    const first = arr[0];
+    if (typeof first !== 'object' || first === null || Array.isArray(first))
+        return false;
+    const keys = Object.keys(first);
+    return keys.some(k => /^pageinit/.test(k) ||
+        /^customcode/.test(k) ||
+        /^contextswitch/.test(k) ||
+        k === 'setVariable' ||
+        k === 'loginbtn' ||
+        /^sz[A-Z]/.test(k));
+}
+/** Convert camelCase / underscore identifiers to human-readable form. */
+function fzeHumanize(s) {
+    // Expand common abbreviations before splitting
+    const expanded = s
+        .replace(/\bOppty\b/gi, 'Opportunity')
+        .replace(/\bMgmt\b/gi, 'Management')
+        .replace(/\bFrm\b/gi, 'Form')
+        .replace(/\bDtl(s)?\b/gi, 'Details')
+        .replace(/\bCust\b/gi, 'Customer')
+        .replace(/\bProsp(ect)?\b/gi, 'Prospect')
+        .replace(/\bAuth\b/gi, 'Authentication')
+        .replace(/\bConf\b/gi, 'Configuration')
+        .replace(/\bAdmin\b/gi, 'Administration')
+        .replace(/\bDashb(oard)?\b/gi, 'Dashboard');
+    const spaced = expanded
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .replace(/[_-]+/g, ' ')
+        .trim();
+    return spaced.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+/** True when a value is a code reference rather than a concrete test data value.
+ * Env/random/local tokens should NOT be stored in formData — the linked env config DataSet
+ * provides actual values, and storing env refs alongside them causes duplicate display. */
+function fzeIsDynamic(v) {
+    return /^dynamic/i.test(v) || /^\{\{\s*fze\.(env|random|local|project)\./i.test(v);
+}
+/** Convert FZE template tokens to readable display strings for step text. */
+function humanizeFzeToken(s) {
+    return s
+        .replace(/\{\{\s*fze\.randomText\((\d+)\)\s*\}\}/gi, (_, n) => `[random ${n}-char text]`)
+        .replace(/\{\{\s*fze\.randomString\((\d+)\)\s*\}\}/gi, (_, n) => `[random ${n}-char text]`)
+        .replace(/\{\{\s*fze\.randomEmail\s*\(\s*(?:'([^']*)'|"([^"]*)")?\s*\)\s*\}\}/gi, (_, d1, d2) => `[random email @${d1 || d2 || 'example.com'}]`)
+        .replace(/\{\{\s*fze\.randomPhone\s*\(\s*\)\s*\}\}/gi, '[random phone]')
+        .replace(/\{\{\s*fze\.randomDoB\s*\([^)]*\)\s*\}\}/gi, '[random date of birth]')
+        .replace(/\{\{\s*fze\.randomFirstName\s*\(\s*\)\s*\}\}/gi, '[random first name]')
+        .replace(/\{\{\s*fze\.randomLastName\s*\(\s*\)\s*\}\}/gi, '[random last name]')
+        .replace(/\{\{\s*fze\.randomNumber\s*\([^)]*\)\s*\}\}/gi, '[random number]')
+        .replace(/\{\{\s*fze\.uuid\s*\(\s*\)\s*\}\}/gi, '[random UUID]')
+        .replace(/\{\{\s*fze\.timestamp\s*\(\s*\)\s*\}\}/gi, '[timestamp]')
+        .replace(/\{\{\s*fze\.date\s*\(\s*\)\s*\}\}/gi, '[today date]')
+        .replace(/\{\{\s*fze\.local\.([^}\s]+)\s*\}\}/gi, (_, v) => `[captured: ${v}]`);
+}
+/** Pick the selected value from a multi-line dropdown options string. */
+function pickFzeSelection(raw) {
+    const lines = raw.split(/[\r\n]+/).map(l => l.trim()).filter(Boolean);
+    const skip = /^(-{0,2}select|--choose|select all)/i;
+    return (lines.find(l => !skip.test(l)) ?? lines[0] ?? raw).split('\n')[0].trim();
+}
+function sanitizeFzeKey(raw) {
+    const clean = raw
+        .replace(/FUNCOPR|FUNCVAL|FUNCOPREND|FUNCVALEND/g, '')
+        .replace(/[^a-zA-Z0-9\s]/g, ' ')
+        .trim();
+    if (!clean)
+        return 'field';
+    const words = clean.split(/\s+/).filter(Boolean);
+    return words[0].charAt(0).toLowerCase() + words[0].slice(1) +
+        words.slice(1).map(w => w.charAt(0).toUpperCase() + w.slice(1)).join('');
+}
+/**
+ * Decode one Functionize key→value pair into a human-readable step descriptor.
+ * Returns null for keys that should be silently skipped (e.g. paired-field bases
+ * whose _1 sibling carries the actual value).
+ *
+ * @param key      Raw FZE key string
+ * @param value    String value (already trimmed)
+ * @param allKeys  Full list of keys in the current recording object — used for
+ *                 paired-field detection (szField + szField_1 pattern).
+ */
+function decodeFzeKey(key, value, allKeys) {
+    // ── Navigation ─────────────────────────────────────────────────────────────
+    if (/^pageinit/.test(key) || key === 'navigate') {
+        return value ? { action: `Navigate to: ${value}` } : null;
+    }
+    // ── Custom JavaScript / variable assignment ────────────────────────────────
+    if (/^customcode/.test(key) || key === 'setVariable') {
+        if (!value)
+            return null;
+        const summary = value.split('\n')[0].trim().slice(0, 100).replace(/\s+/g, ' ');
+        return { action: `Execute script (${key}): ${summary}`, isScript: true };
+    }
+    // ── Context / iframe / window switch ──────────────────────────────────────
+    if (/^contextswitch/.test(key)) {
+        return { action: value ? `Switch context: "${value}"` : 'Switch context', isContextSwitch: true };
+    }
+    // ── Conditional / branching ────────────────────────────────────────────────
+    if (/^conditional/.test(key)) {
+        return value ? { action: `[Conditional] ${value.slice(0, 150)}`, isConditional: true } : null;
+    }
+    // ── Credentials ────────────────────────────────────────────────────────────
+    // Username shown as-is (test account, not PII). Password always masked.
+    if (key === 'user')
+        return { action: value ? `Enter username: "${value}"` : 'Enter username', isCredential: true, inputField: 'username' };
+    if (key === 'Password')
+        return { action: `Enter password: [protected]`, isCredential: true };
+    if (key === 'loginbtn')
+        return value ? { action: `Click login button: "${value}"`, isCredential: true } : null;
+    // ── ASP.NET ctl* controls ──────────────────────────────────────────────────
+    if (key.startsWith('ctl')) {
+        const m = key.match(/(txt|btn|ddl|chk|rad)([A-Z][A-Za-z0-9]+?)(?:SF)?(?:_\d+)?$/);
+        if (m) {
+            const [, type, rawName] = m;
+            const fieldName = fzeHumanize(rawName);
+            const locator = rawName;
+            if (type === 'btn')
+                return value ? { action: `Click button: "${value}"`, locator } : null;
+            if (type === 'ddl')
+                return value ? { action: `Select "${value}" from ${fieldName} dropdown`, locator, inputField: rawName } : null;
+            if (type === 'txt')
+                return value ? { action: `Enter "${value}" in ${fieldName} field`, locator, inputField: rawName } : null;
+            if (type === 'chk')
+                return { action: `${value === 'on' || value === 'true' ? 'Check' : 'Uncheck'} "${fieldName}" checkbox`, locator };
+            if (type === 'rad')
+                return value ? { action: `Select radio option "${value}" for ${fieldName}`, locator } : null;
+        }
+        return value ? { action: `Set form control "${fzeHumanize(key)}": "${value}"` } : null;
+    }
+    // ── Paired-field base detection ────────────────────────────────────────────
+    // Keys like szField, listField, txtField, inputInput, reason, typeaheaddropdown
+    // come in pairs: base = current/options, base_1 = target value to set.
+    // Skip the base if its _1 sibling exists (will be processed when _1 is reached).
+    const pairedBaseRe = /^(sz|list|lSource[A-Z]|l[A-Z][a-z]|txt[A-Z]|inputInput|inputINPUT|reason|typeaheaddropdown|multiselectdropdown)(.*)$/;
+    if (pairedBaseRe.test(key) && !/_\d+$/.test(key) && allKeys.includes(`${key}_1`))
+        return null;
+    // ── sz* — CRM text/input fields (prospect, customer, vehicle data) ─────────
+    if (/^sz[A-Z]/.test(key)) {
+        if (!value)
+            return null;
+        const baseName = key.replace(/^sz/, '').replace(/_\d+$/, '');
+        const fieldName = fzeHumanize(baseName);
+        // Strip sz prefix; use same PascalCase rawName as ctl*txt so 'szZip' → 'Zip'.
+        // Aligns with ctl*txt rawName keys and deduplicates when both patterns appear.
+        const inputField = baseName;
+        return { action: `Enter "${value}" in ${fieldName} field`, inputField };
+    }
+    // ── txt* — generic text inputs (txtSsn, txtBirthday, txtQuickSearch…) ─────
+    if (/^txt[A-Z]/.test(key)) {
+        if (!value)
+            return null;
+        const locator = key.replace(/_\d+$/, '');
+        const fieldName = fzeHumanize(locator.replace(/^txt/, ''));
+        return { action: `Enter "${value}" in ${fieldName} field`, locator, inputField: locator };
+    }
+    // ── list* / lSource* / l[A-Z] — dropdown selections ───────────────────────
+    if (/^(list|lSource[A-Z]|l[A-Z])/.test(key)) {
+        if (!value)
+            return null;
+        const baseName = key.replace(/_\d+$/, '');
+        const fieldName = fzeHumanize(baseName.replace(/^list/, '').replace(/^l/, ''));
+        const selection = pickFzeSelection(value);
+        return { action: `Select "${selection}" from ${fieldName} dropdown`, inputField: baseName };
+    }
+    // ── inputInput / inputINPUT — generic typed inputs ─────────────────────────
+    if (/^input(Input|INPUT)/.test(key)) {
+        if (!value)
+            return null;
+        return { action: `Type in input field: "${value}"`, inputField: 'input' };
+    }
+    // ── typeaheaddropdown — typeahead / autocomplete ───────────────────────────
+    if (/^typeaheaddropdown/.test(key)) {
+        if (!value)
+            return null;
+        const selection = pickFzeSelection(value);
+        return { action: `Type and select: "${selection}"`, inputField: 'typeahead' };
+    }
+    // ── multiselectdropdown — multi-select filter fields ──────────────────────
+    if (/^multiselectdropdown/.test(key)) {
+        if (!value)
+            return null;
+        // FZE encodes multi-select as "OR|FUNCOPR|Val1|FUNCVAL|Val2"
+        const options = value
+            .replace(/OR\|FUNCOPR\|/g, '')
+            .replace(/\|FUNCVAL\|/g, ', ')
+            .replace(/\|FUNCOPR\|/g, ', ');
+        return { action: `Multi-select: ${options}`, inputField: 'multiselect' };
+    }
+    // ── cb* — checkboxes ───────────────────────────────────────────────────────
+    if (/^cb[A-Z]/.test(key)) {
+        const fieldName = fzeHumanize(key.replace(/^cb/, ''));
+        const checked = value === 'on' || value === 'true' || value === '1';
+        return { action: `${checked ? 'Check' : 'Uncheck'} "${fieldName}" checkbox`, locator: key };
+    }
+    // ── radio* — radio button selections ──────────────────────────────────────
+    if (/^radio/.test(key)) {
+        if (!value)
+            return null;
+        const fieldName = fzeHumanize(key.replace(/^radio/, ''));
+        return { action: `Select radio option "${value}"${fieldName ? ` for ${fieldName}` : ''}`, locator: key };
+    }
+    // ── reason* — reason / comment textareas ──────────────────────────────────
+    if (/^reason/.test(key)) {
+        if (!value)
+            return null;
+        return { action: `Enter reason: "${value}"`, inputField: 'reason' };
+    }
+    // ── textareadefault — generic textarea ────────────────────────────────────
+    if (/^textareadefault/.test(key)) {
+        return value ? { action: `Type in text area: "${value}"`, inputField: 'textarea' } : null;
+    }
+    // ── btn* — standalone buttons (not ASP.NET ctl) ───────────────────────────
+    if (/^btn[A-Z]/.test(key)) {
+        return value ? { action: `Click button: "${value}"`, locator: key } : null;
+    }
+    // ── select* — explicit select dropdowns ───────────────────────────────────
+    if (/^select[A-Z]/.test(key)) {
+        if (!value)
+            return null;
+        const fieldName = fzeHumanize(key.replace(/^select/, '').replace(/_\d+$/, ''));
+        return { action: `Select "${value}" from ${fieldName || 'dropdown'}`, inputField: key.replace(/_\d+$/, '') };
+    }
+    // ── Click actions ──────────────────────────────────────────────────────────
+    if (key.startsWith('click')) {
+        const sub = key.slice(5); // everything after "click"
+        // Anchor / hyperlinks
+        if (/^A([_$\d]|$)/.test(sub))
+            return { action: value ? `Click link: "${value}"` : 'Click link' };
+        // Buttons
+        if (/^Button/.test(sub)) {
+            const locator = sub.replace(/_\d+$/, '');
+            return { action: value ? `Click button: "${value}"` : 'Click button', locator };
+        }
+        // Tabs
+        if (/^Tab/.test(sub))
+            return { action: value ? `Click tab: "${value}"` : 'Click tab' };
+        // Images / icons
+        if (/^Img/.test(sub))
+            return { action: value ? `Click image: "${value}"` : 'Click image' };
+        if (/^Svg/.test(sub))
+            return { action: value ? `Click icon: "${value}"` : 'Click icon' };
+        // Spans
+        if (/^Span/.test(sub) || /^SPAN/.test(sub))
+            return { action: value ? `Click: "${value}"` : 'Click element' };
+        // Text nodes
+        if (/^Text/.test(sub))
+            return value ? { action: `Click text: "${value}"` } : null;
+        // Links (Lnk prefix)
+        if (/^Lnk/.test(sub)) {
+            const lnkName = fzeHumanize(sub.replace(/^Lnk/, '').replace(/_\d+$/, ''));
+            return { action: value ? `Click link: "${value}"` : `Click ${lnkName} link` };
+        }
+        // Logout/legacy buttons (Lb prefix)
+        if (/^Lb/.test(sub))
+            return { action: value ? `Click: "${value}"` : `Click ${fzeHumanize(sub.replace(/^Lb/, ''))}` };
+        // Bare B (button/bold element)
+        if (/^B([_$\d]|$)/.test(sub))
+            return { action: value ? `Click: "${value}"` : 'Click button' };
+        // List items
+        if (/^Li([_$\d]|$)/.test(sub))
+            return value ? { action: `Click list item: "${value}"` } : null;
+        // Input clicks
+        if (/^(INPUT|In(put|PUT)?)([_$\d]|$)/.test(sub))
+            return { action: value ? `Click input: "${value}"` : 'Click input' };
+        // Brand logo / app switcher
+        if (/^BrandImage/.test(sub))
+            return { action: value ? `Click brand logo: "${value}"` : 'Click brand logo' };
+        // Checkbox via click
+        if (/^Ckb/.test(sub)) {
+            const fieldName = fzeHumanize(sub.replace(/^Ckb/, '').replace(/_\d+$/, ''));
+            return { action: `${value === 'on' || !value ? 'Check' : 'Uncheck'} "${fieldName}"`, locator: sub };
+        }
+        // Multi-lender / desking filter chips
+        if (/^DMulti/.test(sub))
+            return value ? { action: `Click filter: "${value}"` } : null;
+        // Menu navigation (clickMenuSections_SectionLabel_2, etc.)
+        if (/^MenuSections/.test(sub)) {
+            return { action: value ? `Navigate menu: "${value}"` : `Click nav: ${fzeHumanize(sub.replace(/^MenuSections_/, ''))}` };
+        }
+        // Dashboard / reporting elements
+        if (/^Dashboard/.test(sub) || /^Dashboard/i.test(sub)) {
+            return { action: value ? `Click dashboard element: "${value}"` : 'Click dashboard element' };
+        }
+        // Table cells / rows
+        if (/^Td/.test(sub))
+            return value ? { action: `Click table cell: "${value}"` } : null;
+        // Divs — filter dropdown noise
+        if (/^Div/.test(sub)) {
+            const sel = pickFzeSelection(value);
+            return { action: sel ? `Click: "${sel}"` : 'Click element' };
+        }
+        // Generic fallback
+        const elType = sub.replace(/_\d+$/, '').replace(/([A-Z])/g, ' $1').trim();
+        return { action: value ? `Click ${elType}: "${value}"` : `Click ${elType}` };
+    }
+    // ── Assertions (verify*) ──────────────────────────────────────────────────
+    if (key.startsWith('verify')) {
+        if (!value)
+            return null;
+        // Decode FUNCOPR multi-value encoding (e.g. "OR|FUNCOPR|Dark Mode|FUNCVAL|") before display
+        const displayValue = value.includes('FUNCOPR') || value.includes('FUNCVAL')
+            ? value
+                .replace(/^OR\|FUNCOPR\|/, '')
+                .replace(/\|FUNCVAL\|([^|]*)\|?/g, (_, b) => b.trim() ? ` or ${b.trim()}` : '')
+                .replace(/\|FUNCOPR\|/g, ', ')
+                .trim()
+            : value;
+        // Extract assertion property suffix
+        const propMatch = key.match(/_(text|url|value|attr_id|visibility|attr_[a-z_]+)(\d+)?$/i);
+        const prop = propMatch?.[1]?.toLowerCase() ?? 'text';
+        // Extract locator: strip "verify" prefix and property suffix + index
+        const locator = key
+            .replace(/^verify/, '')
+            .replace(/_(text|url|value|attr_id|visibility|attr_[a-z_]+)\d*$/i, '')
+            .replace(/_\d+$/, '');
+        // URL assertion
+        if (prop === 'url')
+            return { action: `Verify URL contains: "${displayValue}"`, isAssertion: true, locator };
+        // Visibility assertion
+        if (prop === 'visibility') {
+            return { action: `Verify "${locator || 'element'}" is ${value === 'true' ? 'visible' : 'hidden'}`, isAssertion: true, locator };
+        }
+        // Attribute assertions
+        if (prop === 'attr_id')
+            return { action: `Verify element attribute id: "${displayValue}"`, isAssertion: true, locator };
+        if (prop.startsWith('attr_')) {
+            const attrName = prop.slice(5);
+            return { action: `Verify ${attrName} attribute: "${displayValue}"`, isAssertion: true, locator };
+        }
+        // Value assertions (input field values, incl. dynamic variable refs)
+        if (prop === 'value') {
+            const isDyn = fzeIsDynamic(value);
+            return { action: `Verify field value: "${displayValue}"${isDyn ? ' (captured dynamic value)' : ''}`, isAssertion: true, locator };
+        }
+        // Hash-based locators (e.g. verify6b300a51cba242d1834a775414fb51ffheading_text)
+        if (/^[0-9a-f]{10,}/i.test(locator)) {
+            const suffix = locator.replace(/^[0-9a-f]+/i, '');
+            return { action: `Verify ${fzeHumanize(suffix) || 'heading'}: "${displayValue}"`, isAssertion: true };
+        }
+        // Breadcrumb / dashboard title / page-level assertions
+        if (/^BreadcrumbContainer/i.test(locator))
+            return { action: `Verify breadcrumb: "${displayValue}"`, isAssertion: true };
+        if (/^DashboardTitle/i.test(locator))
+            return { action: `Verify dashboard title: "${displayValue}"`, isAssertion: true };
+        if (/^Top$/i.test(locator))
+            return { action: `Verify page header contains: "${displayValue.split('\n')[0].trim()}"`, isAssertion: true };
+        if (/^CurrentDashBoardSection/i.test(locator))
+            return { action: `Verify current section: "${displayValue}"`, isAssertion: true };
+        // Standard element text assertion
+        const elMatch = locator.match(/^([A-Z][a-z]+)/);
+        const elType = elMatch?.[1] ?? 'element';
+        return { action: `Verify ${fzeHumanize(elType)} text: "${displayValue}"`, isAssertion: true, locator };
+    }
+    // Unknown key: emit generic step so nothing is silently dropped
+    if (value) {
+        const humanKey = fzeHumanize(key.replace(/_\d+$/, '').replace(/([A-Z])/g, ' $1').trim().replace(/\s+/g, ' '));
+        return { action: `${humanKey}: "${value.slice(0, 200)}"` };
+    }
+    return null;
+}
+// ── Excel FZE parser ─────────────────────────────────────────────────────────
+// Converts a pipe-table (extracted from .xlsx) into FZE objects and parses them.
+// Supports two layouts:
+//   Multi-column: first row = all FZE action keys, each data row = one test case
+//   Transposed 2-col: col A = key name, col B = value — all rows = one test case
+function tryParseFzeExcel(content, sourcePlatform) {
+    const parseCells = (line) => line.split('|').slice(1, -1).map(c => c.trim());
+    const isFzeKey = (s) => /^(pageinit|customcode|user|Password|loginbtn|contextswitch|conditional|setVariable|sz[A-Z]|txt[A-Z]|list|lSource|verify|click|inputInput|inputINPUT|btn[A-Z]|typeaheaddropdown|multiselectdropdown|navigate|radio|reason|cb[A-Z]|select[A-Z]|textareadefault|ctl)/i.test(s.trim());
+    const lines = content.split('\n')
+        .map(l => l.trim())
+        .filter(l => l.startsWith('|') && !l.match(/^[\s|:-]+$/));
+    if (lines.length < 2)
+        return null;
+    // Find the first line where col 0 is pageinit or an FZE key (resilient to leading sheet/title/header rows)
+    const firstFzeIdx = lines.findIndex(l => {
+        const firstCell = parseCells(l)[0]?.toLowerCase() ?? '';
+        return firstCell === 'pageinit' || isFzeKey(firstCell);
+    });
+    if (firstFzeIdx === -1)
+        return null;
+    const candidateLines = lines.slice(firstFzeIdx);
+    const headers = parseCells(candidateLines[0]);
+    // Detect transposed (2-column) vs multi-column by checking if candidateLines[1] col-0 is an FZE key
+    const isTransposed = candidateLines.length > 1 && isFzeKey(parseCells(candidateLines[1] ?? '')[0] ?? '');
+    let fzeObjects;
+    if (isTransposed) {
+        const obj = {};
+        for (const line of candidateLines) {
+            const cells = parseCells(line);
+            const key = cells[0] ?? '';
+            if (key)
+                obj[key] = cells[1] ?? '';
+        }
+        fzeObjects = [obj];
+    }
+    else {
+        fzeObjects = candidateLines.slice(1).map(line => {
+            const cells = parseCells(line);
+            const obj = {};
+            headers.forEach((h, i) => { if (h)
+                obj[h] = cells[i] ?? ''; });
+            return obj;
+        });
+    }
+    if (!fzeObjects.length)
+        return null;
+    return parseFunctionizeCases(fzeObjects, sourcePlatform);
+}
+// ── Main case builder ─────────────────────────────────────────────────────────
+function parseFunctionizeCases(arr, sourcePlatform) {
+    const cases = [];
+    const errors = [];
+    for (let idx = 0; idx < arr.length; idx++) {
+        const rec = arr[idx];
+        if (typeof rec !== 'object' || rec === null || Array.isArray(rec))
+            continue;
+        const allKeys = Object.keys(rec);
+        // Capture explicit test case ID if present in the Functionize record
+        const explicitRef = rec.id != null ? String(rec.id)
+            : rec.testId != null ? String(rec.testId)
+                : rec.testCaseId != null ? String(rec.testCaseId)
+                    : rec.test_case_id != null ? String(rec.test_case_id)
+                        : rec['TC ID'] != null ? String(rec['TC ID'])
+                            : rec['TC_ID'] != null ? String(rec['TC_ID'])
+                                : null;
+        const steps = [];
+        const customScripts = [];
+        const formData = {};
+        const credentials = {};
+        const urls = [];
+        const selectionValues = [];
+        let lastAssertion = '';
+        let contextSwitchCount = 0;
+        for (const key of allKeys) {
+            const rawVal = rec[key];
+            const value = String(rawVal ?? '').trim();
+            // Skip metadata keys already captured (IDs, etc.)
+            if (key === 'id' || key === 'testId' || key === 'testCaseId' || key === 'test_case_id' || key === 'TC ID' || key === 'TC_ID')
+                continue;
+            // Collect credentials for testDataInline, but still emit steps for locator extraction.
+            // decodeFzeKey handles these with masked action text (real password never in step text).
+            if (key === 'user') {
+                if (value)
+                    credentials.username = value;
+            }
+            if (key === 'Password') {
+                credentials.hasPassword = 'true';
+                if (value)
+                    credentials.password = value;
+            }
+            // Collect and record custom scripts in testDataInline
+            if (/^customcode/.test(key) || key === 'setVariable') {
+                if (value) {
+                    customScripts.push({ name: key, code: value });
+                    const summary = value.split('\n')[0].trim().slice(0, 120).replace(/\s+/g, ' ');
+                    steps.push({ action: `Execute script (${key}): ${summary}`, data: `script:${key}`, expected: '' });
+                }
+                continue;
+            }
+            // Track all navigation URLs (pageinit + navigate keys) — include fze.env.* URL placeholders
+            if ((/^pageinit/.test(key) || key === 'navigate') && value && (value.startsWith('http') || /^\{\{\s*fze\.env\./i.test(value)))
+                urls.push(value);
+            // Context switches: enrich step text with iframe selector hints so script-agent
+            // can generate a real switchToFrame() call instead of a stub.
+            // NOTE: Many FZE recordings use empty-string contextswitch values — the empty string
+            // means "switch context here" with no explicit frame name. We ALWAYS emit a step
+            // (even for empty values) so no context switch is silently dropped.
+            if (/^contextswitch/.test(key)) {
+                contextSwitchCount++;
+                let contextHint = '';
+                if (!value || value === 'main' || value === 'default' || value === 'top') {
+                    // Empty or "main" — infer from surrounding URL context.
+                    // When contextswitch is empty, Functionize marks a frame/window boundary with no explicit name.
+                    // Look at the most recent URLs to determine if we're entering an embed (e.g. Looker) or returning.
+                    const lastUrl = urls.length > 0 ? urls[urls.length - 1] : '';
+                    const embedUrl = urls.find(u => /looker|embed|iframe|frame|chart|analytics|dashboard/.test(u));
+                    if (!value || value === 'main' || value === 'default' || value === 'top') {
+                        // Empty = entering or leaving a frame boundary; check if we have an embed URL context
+                        if (embedUrl) {
+                            try {
+                                const embedHost = new URL(embedUrl).hostname;
+                                // Alternating empty contextswitches = enter/exit the embed iframe
+                                const isEven = contextSwitchCount % 2 === 1; // odd = enter, even = exit
+                                if (isEven) {
+                                    contextHint = ` (enter embedded frame — use switchToFrame('iframe[src*="${embedHost}"]'))`;
+                                }
+                                else {
+                                    contextHint = ` (exit embedded frame — use switchToDefaultContent() or page.mainFrame())`;
+                                }
+                            }
+                            catch { /* ignore */ }
+                        }
+                        else if (lastUrl) {
+                            // Determine popup vs iframe from URL patterns.
+                            // Popup/new-tab: kiosk forms, explicit popup/window path segments, different-host navigations.
+                            // Iframe (default): same-host ASP.NET frames, embedded content without popup markers.
+                            const isPopupPattern = /kiosk|popup|newwindow|new[_-]?window|new[_-]?tab|modal|_frm_new|opendialog/i.test(lastUrl);
+                            const shortUrl = lastUrl.replace(/^https?:\/\//, '').slice(0, 60);
+                            if (isPopupPattern) {
+                                contextHint = ` (new tab/popup — use switchToPopup(); last URL: ${shortUrl})`;
+                            }
+                            else {
+                                contextHint = ` (iframe boundary after ${shortUrl} — use switchToFrame('iframe'))`;
+                            }
+                        }
+                        else {
+                            contextHint = ' (return to main frame — use switchToDefaultContent())';
+                        }
+                    }
+                    steps.push({ action: `Switch to context: "${value || 'unnamed'}"${contextHint}`, expected: '' });
+                }
+                else if (/^\d+$/.test(value)) {
+                    const idx = parseInt(value, 10);
+                    steps.push({ action: `Switch to context: "${value}" — iframe index ${value} (use page.frames()[${idx}] or iframe:nth-of-type(${idx + 1}))`, expected: '' });
+                }
+                else if (value.startsWith('http')) {
+                    try {
+                        const embedHost = new URL(value).hostname;
+                        steps.push({ action: `Switch to context: "${value}" — embedded URL (use iframe[src*="${embedHost}"] as selector)`, expected: '' });
+                    }
+                    catch {
+                        steps.push({ action: `Switch to context: "${value}"`, expected: '' });
+                    }
+                }
+                else {
+                    // Named context — use the name as iframe[name=] and also check collected embed URLs
+                    const embedUrl = urls.find(u => /embed|looker|iframe|frame/.test(u));
+                    if (embedUrl) {
+                        try {
+                            const embedHost = new URL(embedUrl).hostname;
+                            contextHint = ` — likely embedded frame (try iframe[src*="${embedHost}"] or iframe[name="${value}"])`;
+                        }
+                        catch { /* ignore */ }
+                    }
+                    else {
+                        contextHint = ` — named frame/window "${value}" (use switchToFrame('iframe[name="${value}"]') or switchToPopup())`;
+                    }
+                    steps.push({ action: `Switch to context: "${value}"${contextHint}`, expected: '' });
+                }
+                continue;
+            }
+            // Conditionals: emit as if/else step so script-agent generates branching code.
+            // FZE conditional values are JavaScript return-expressions, e.g.:
+            //   "return fze.action('ID').resultCode !== 'S' && !location.href.includes('qa');"
+            // They contain ONLY the condition — branch body steps are in subsequent FZE records.
+            if (/^conditional/.test(key)) {
+                if (value) {
+                    // Pattern 1: FZE-style "return <bool-expr>;" — extract the expression
+                    const returnMatch = value.match(/^return\s+([\s\S]{1,500}?)\s*;?\s*$/i);
+                    // Pattern 2: Classic "if (<cond>) { ... }" structure
+                    const ifMatch = value.match(/^if\s*\(([^)]{1,200})\)\s*\{?([\s\S]{0,200})/i);
+                    if (returnMatch) {
+                        const condition = returnMatch[1].trim();
+                        // Translate fze.action().resultCode patterns to human-readable form
+                        const readable = condition
+                            .replace(/fze\.action\(['"]([\w-]+)['"]\)\.resultCode\s*!==?\s*['"](\w+)['"]/g, 'previous action result-code ≠ "$2"')
+                            .replace(/fze\.action\(['"]([\w-]+)['"]\)\.resultCode\s*===?\s*['"](\w+)['"]/g, 'previous action result-code = "$2"')
+                            .replace(/location\.href\.includes\(['"]([^'"]+)['"]\)/g, 'current URL contains "$1"')
+                            .replace(/fze\.local\.(\w+)\.includes\(['"]([^'"]+)['"]\)/g, 'local var $1 contains "$2"');
+                        steps.push({
+                            action: `[Conditional branch] Condition: ${readable} (raw: ${condition.slice(0, 200)}). Execute next step only if this condition is true — generate an if/else block using page.url(), element visibility, or response assertion for the check.`,
+                            expected: '',
+                        });
+                    }
+                    else if (ifMatch) {
+                        const [, condition, branch] = ifMatch;
+                        const branchSummary = branch.replace(/\s+/g, ' ').trim().slice(0, 120);
+                        steps.push({
+                            action: `[Conditional branch] if (${condition.trim()}) → ${branchSummary || 'execute branch'}. Generate an if/else block: check element visibility or response value for condition, run branch steps if true, skip or assert otherwise.`,
+                            expected: '',
+                        });
+                    }
+                    else {
+                        // Fallback: emit full value (up to 500 chars — FZE conditionals are always short JS expressions)
+                        steps.push({ action: `[Conditional branch] ${value.slice(0, 500)}. Generate an if/else block for this condition.`, expected: '' });
+                    }
+                }
+                continue;
+            }
+            const decoded = decodeFzeKey(key, value, allKeys);
+            if (!decoded)
+                continue;
+            if (decoded.isAssertion && value && !/^\{\{\s*fze\.(local|env|random|uuid)\./i.test(value))
+                lastAssertion = value;
+            // Accumulate form data for testDataInline.
+            // Dynamic refs stored as markers ([env:X], [dynamic], [dynamic:email]) so script generation
+            // can emit process.env.X / Math.random() instead of discarding these fields entirely.
+            if (decoded.inputField && value) {
+                if (fzeIsDynamic(value)) {
+                    const envM = value.match(/^\{\{\s*fze\.env\.([^}\s]+?)\s*\}\}$/i);
+                    if (envM) {
+                        formData[sanitizeFzeKey(decoded.inputField)] = `[env:${envM[1]}]`;
+                    }
+                    else if (/email/i.test(decoded.inputField)) {
+                        formData[sanitizeFzeKey(decoded.inputField)] = '[dynamic:email]';
+                    }
+                    else {
+                        formData[sanitizeFzeKey(decoded.inputField)] = '[dynamic]';
+                    }
+                }
+                else if (/^multiselectdropdown/.test(key)) {
+                    // Decode FZE multi-select format ("OR|FUNCOPR|Val1|FUNCVAL|Val2") before storing
+                    formData[sanitizeFzeKey(decoded.inputField)] = value
+                        .replace(/OR\|FUNCOPR\|/g, '')
+                        .replace(/\|FUNCVAL\|/g, ', ')
+                        .replace(/\|FUNCOPR\|/g, ', ')
+                        .trim();
+                }
+                else {
+                    const normalizeFzeValue = (v) => v.replace(/\{\{fze\.env\.([^}]+)\}\}/g, '[env:$1]')
+                        .replace(/\{\{fze\.randomText\(\d*\)\}\}/g, '[dynamic:text]')
+                        .replace(/\{\{fze\.randomEmail\(\)\}\}/g, '[dynamic:email]')
+                        .replace(/\{\{fze\.local\.([^}]+)\}\}/g, '[$1]');
+                    formData[sanitizeFzeKey(decoded.inputField)] = normalizeFzeValue(value);
+                    // Canonicalize email field to consistent key
+                    if (/email/i.test(decoded.inputField) && !formData.email) {
+                        formData.email = value;
+                    }
+                    // Also capture common CRM field names for email
+                    if (/szEmail|txtEmail|emailAddress|email_address/i.test(decoded.inputField) && !formData.email) {
+                        formData.email = value;
+                    }
+                }
+            }
+            // Capture dropdown/list-item click selections for test data context
+            if (!decoded.inputField && value && !fzeIsDynamic(value) && value.length < 200) {
+                const clickSub = key.startsWith('click') ? key.slice(5) : '';
+                if (/^(Div|Span|Li)/.test(clickSub)) {
+                    const sel = (pickFzeSelection(value) || value).trim();
+                    if (sel)
+                        selectionValues.push(sel);
+                }
+                else if (/^Button/.test(clickSub)) {
+                    // Date range button clicks (e.g. date picker "02/01/2025 - 02/13/2025")
+                    if (/\d{1,2}\/\d{1,2}\/\d{4}/.test(value) && !formData.dateRange) {
+                        formData.dateRange = value.split('\n')[0].trim().slice(0, 60);
+                    }
+                }
+            }
+            let locatorComment;
+            if (decoded.locator) {
+                const semanticHint = tryConvertXPathToSemantic(decoded.locator);
+                if (semanticHint) {
+                    locatorComment = `locatorHint: ${semanticHint}`;
+                }
+                else if (decoded.locator.trim().startsWith('/')) {
+                    locatorComment = `xpathFallback: ${decoded.locator}`;
+                }
+                else {
+                    locatorComment = `locator: ${decoded.locator}`;
+                }
+            }
+            steps.push({
+                action: humanizeFzeToken(decoded.action),
+                data: decoded.inputField && value ? humanizeFzeToken(value) : undefined,
+                expected: decoded.isAssertion ? humanizeFzeToken(value) : '',
+                ...(locatorComment ? { comment: locatorComment } : {}),
+            });
+        }
+        if (steps.length === 0)
+            continue;
+        // Build title from semantic signals — priority: menu navigation > URL title params > URL path segments
+        const realUrls = urls.filter(u => u.startsWith('http'));
+        const firstUrl = realUrls[0] ?? '';
+        let title = `Test Case ${idx + 1}`;
+        const GENERIC_SEGS = new Set(['index', 'viewer', 'render', 'default', 'home', 'main', 'dashboard', 'app', 'fresh', 'evo2', 'login']);
+        // Generic UI states/filters that don't describe WHAT is being tested
+        const GENERIC_MENU_ITEMS = new Set(['active', 'inactive', 'all', 'new', 'home', 'back', 'list', 'search', 'filter', 'none', 'yes', 'no', 'ok', 'cancel']);
+        // Priority 1: menu navigation items — "Navigate menu: X" are the clearest semantic signal
+        const menuItems = steps
+            .filter(s => s.action.startsWith('Navigate menu:'))
+            .map(s => s.action.replace(/^Navigate menu:\s*"?/, '').replace(/"$/, '').trim())
+            .filter(Boolean);
+        // Extract last meaningful assertion — two-pass: expected VALUES first (all steps), then action-name fallback.
+        // Two-pass prevents short abbreviations like "Oppt" (from action text) from blocking a good
+        // expected value ("Home or Accueil") that appears earlier in the step list.
+        const lastAssertEl = (() => {
+            const TRIVIAL_EXPECTED = /^(svg|home|index|true|false|\d+|refresh|active|prospects|inactive|all|new|accueil)$/i;
+            // Pass 1: find the last step with a meaningful expected VALUE
+            for (let i = steps.length - 1; i >= 0; i--) {
+                const exp = steps[i].expected;
+                if (exp && exp.length > 4 && exp.length < 80 && !TRIVIAL_EXPECTED.test(exp))
+                    return exp;
+            }
+            // Pass 2: fall back to action-name extraction — require 5+ chars to exclude CRM abbreviations (Oppt, Div, Td)
+            for (let i = steps.length - 1; i >= 0; i--) {
+                const a = steps[i].action;
+                const m = a.match(/^Verify\s+([A-Za-z]{5,})\s+(?:text|value|field):/i);
+                if (m && !['Span', 'Label', 'Brand', 'Field', 'Input'].includes(m[1]))
+                    return m[1];
+            }
+            return '';
+        })();
+        // Meaningful menu items = non-generic (exclude UI state labels like "Active", "All", "Home")
+        const meaningfulMenuItems = menuItems.filter(m => !GENERIC_MENU_ITEMS.has(m.toLowerCase()));
+        if (meaningfulMenuItems.length >= 2) {
+            const primary = meaningfulMenuItems[meaningfulMenuItems.length - 1];
+            const outcome = lastAssertEl ? `Verify ${lastAssertEl}` : `Verify Results`;
+            title = `${primary}: ${outcome}`;
+        }
+        else if (meaningfulMenuItems.length === 1) {
+            title = lastAssertEl ? `${meaningfulMenuItems[0]}: Verify ${lastAssertEl}` : `Verify ${meaningfulMenuItems[0]}`;
+        }
+        else if (lastAssertEl) {
+            title = `Verify ${lastAssertEl}`;
+        }
+        else {
+            // Priority 2: URL title= query params or path segments
+            try {
+                const u = new URL(firstUrl);
+                const page = u.pathname.split('/').filter(Boolean).pop()?.replace(/\.[^.]+$/, '') ?? '';
+                const isMultiPage = realUrls.length > 2 || steps.length > 15;
+                if (isMultiPage) {
+                    const titleParamLabels = [];
+                    const pathSegLabels = [];
+                    for (const raw of realUrls) {
+                        try {
+                            const pu = new URL(raw);
+                            const tp = pu.searchParams.get('title');
+                            if (tp) {
+                                const label = tp.replace(/\+/g, ' ').replace(/%20/g, ' ').trim();
+                                if (label)
+                                    titleParamLabels.push(label);
+                            }
+                            else {
+                                const seg = pu.pathname.split('/').filter(Boolean).pop()?.replace(/\.[^.]+$/, '') ?? '';
+                                // Skip generic segments, pure numbers, all-lowercase compound words, and technical paths
+                                const isCompoundLower = /^[a-z]{10,}$/.test(seg); // all-lowercase = unreadable compound word
+                                if (seg && !GENERIC_SEGS.has(seg.toLowerCase()) && !/^\d+$/.test(seg) && !seg.includes('::') && seg.length < 40 && !isCompoundLower) {
+                                    pathSegLabels.push(fzeHumanize(seg));
+                                }
+                            }
+                        }
+                        catch { /* skip malformed URLs */ }
+                    }
+                    const sourceLabels = titleParamLabels.length > 0 ? titleParamLabels : pathSegLabels;
+                    const uniqueLabels = [...new Set(sourceLabels)].slice(0, 3);
+                    title = uniqueLabels.length > 1
+                        ? `${uniqueLabels[0]}: Verify ${uniqueLabels[uniqueLabels.length - 1]}`
+                        : uniqueLabels.length === 1
+                            ? `Verify ${uniqueLabels[0]} End-to-End`
+                            : fzeHumanize(page) || `${u.hostname} End-to-End Test`;
+                }
+                else {
+                    title = page ? fzeHumanize(page) : u.hostname;
+                }
+            }
+            catch { /* use default */ }
+        }
+        // Preconditions from credentials + start URL
+        const preconditionParts = [
+            credentials.username ? `Login as: ${credentials.username}` : null,
+            firstUrl ? `Start URL: ${firstUrl}` : null,
+        ].filter(Boolean);
+        // Build Gherkin scenario
+        let hasGiven = false, hasWhen = false, hasThen = false;
+        const gherkinLines = [`Scenario: ${title}`];
+        for (const step of steps) {
+            const isNav = step.action.startsWith('Navigate to:');
+            const isAssert = step.expected !== '';
+            const isMeta = step.action.startsWith('[Conditional') || step.action.startsWith('Switch');
+            let kw;
+            if (isAssert) {
+                kw = hasThen ? 'And' : 'Then';
+                hasThen = true;
+            }
+            else if ((isNav || isMeta) && !hasWhen) {
+                kw = hasGiven ? 'And' : 'Given';
+                hasGiven = true;
+            }
+            else {
+                kw = hasWhen ? 'And' : 'When';
+                hasWhen = true;
+            }
+            gherkinLines.push(`  ${kw} ${step.action}`);
+        }
+        if (!hasThen)
+            gherkinLines.push('  Then all steps complete without error');
+        // Assemble testDataInline: form data + scripts + navigation URLs + metadata
+        const testDataInline = {};
+        if (Object.keys(formData).length > 0)
+            Object.assign(testDataInline, formData);
+        if (customScripts.length > 0)
+            testDataInline.customScripts = customScripts;
+        // Store credential env-var markers so script generation can emit process.env.X refs.
+        if (credentials.username) {
+            const envM = credentials.username.match(/^\{\{\s*fze\.env\.([^}\s]+?)\s*\}\}$/i);
+            if (envM) {
+                if (!testDataInline.username)
+                    testDataInline.username = `[env:${envM[1]}]`;
+            }
+            else if (!fzeIsDynamic(credentials.username)) {
+                testDataInline.recordedUser = credentials.username;
+            }
+        }
+        if (credentials.password)
+            testDataInline.recordedPassword = '[env:TEST_USER_PASSWORD]'; // Never store raw credentials in test data — use env var reference
+        if (selectionValues.length > 0)
+            testDataInline.recordedSelections = selectionValues;
+        if (urls.length > 0) {
+            testDataInline.recordedUrls = urls;
+            // Also store first URL as startUrl so buildTestDataBodyFromInline emits it as a named field.
+            if (!testDataInline.startUrl && urls[0]) {
+                const envM = urls[0].match(/^\{\{\s*fze\.env\.([^}\s]+?)\s*\}\}$/i);
+                testDataInline.startUrl = envM ? `[env:${envM[1]}]` : urls[0];
+            }
+        }
+        if (contextSwitchCount > 0)
+            testDataInline.contextSwitches = contextSwitchCount;
+        // Infer test kind from content
+        const hasLogin = allKeys.includes('user') || allKeys.includes('loginbtn');
+        const kind = (urls.length > 4 || steps.length > 12)
+            ? 'E2E'
+            : hasLogin ? 'INTEGRATION' : 'POSITIVE';
+        const priority = customScripts.length > 2 ? 'HIGH' : 'MEDIUM';
+        const allStepsStr = steps.map(s => s.action).join('|');
+        const fzeRefHash = node_crypto_1.default.createHash('sha256').update(allStepsStr + firstUrl).digest('hex').slice(0, 8).toUpperCase();
+        cases.push({
+            ref: explicitRef ? normalizeRef(explicitRef, sourcePlatform ?? 'Functionize') : `${platformPrefix(sourcePlatform ?? 'Functionize')}${fzeRefHash}`,
+            title,
+            kind,
+            priority,
+            preconditions: preconditionParts.length > 0 ? preconditionParts.join('; ') : undefined,
+            steps,
+            expectedResult: lastAssertion
+                ? `Verify: "${lastAssertion}"`
+                : 'All recorded steps complete without error',
+            gherkin: gherkinLines.join('\n'),
+            tags: ['functionize', 'imported'],
+            ...(Object.keys(testDataInline).length > 0 ? { testDataInline } : {}),
+        });
+    }
+    return { cases, errors };
+}
+// ─── JSON direct parser ──────────────────────────────────────────────────────
+function tryParseJsonCases(content, sourcePlatform) {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith('[') && !trimmed.startsWith('{')) {
+        // Try extracting JSON from markdown code fence
+        const fenceMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/);
+        if (fenceMatch)
+            return tryParseJsonCases(fenceMatch[1].trim());
+        // Also handle markdown heading prefix (e.g. "# filename.json\n\n[...") from JSON ingestion
+        if (trimmed.startsWith('#')) {
+            const arrayIdx = trimmed.indexOf('\n[');
+            const objIdx = trimmed.indexOf('\n{');
+            const jsonIdx = arrayIdx !== -1 && objIdx !== -1 ? Math.min(arrayIdx, objIdx)
+                : arrayIdx !== -1 ? arrayIdx : objIdx;
+            if (jsonIdx !== -1)
+                return tryParseJsonCases(trimmed.slice(jsonIdx + 1));
+        }
+        return null;
+    }
+    // Pass 1: standard parse
+    let data;
+    let parseOk = false;
+    try {
+        data = JSON.parse(trimmed);
+        parseOk = true;
+    }
+    catch { /* try repair */ }
+    // Pass 2: state-machine repair (escape literal newlines/carriage-returns inside strings)
+    if (!parseOk) {
+        try {
+            data = JSON.parse(repairJsonStringLiterals(trimmed));
+            parseOk = true;
+        }
+        catch { /* try raw extractor */ }
+    }
+    // Pass 3: line-based raw pair extractor (handles unescaped double-quotes in JS code values)
+    if (!parseOk) {
+        const rawPairs = extractFzeRawPairs(trimmed);
+        if (rawPairs.length > 0 && isFunctionizeFormat(rawPairs)) {
+            return parseFunctionizeCases(rawPairs);
+        }
+        // Pass 3b: regex-based FZE probe — catches compact/unusual formatting where
+        // extractFzeRawPairs still returns []. If FZE markers are present in the raw
+        // text, try bracketing the content and re-parsing with repaired literals.
+        const hasFzeMarkers = /['"](pageinit|loginbtn|customcode|contextswitch|sz[A-Z])['"]\s*:/.test(trimmed);
+        if (hasFzeMarkers) {
+            // Strip outer array wrapper and split on object boundaries to handle
+            // "[{...},{...}]" patterns without relying on line-based structure.
+            const inner = trimmed.replace(/^\s*\[\s*/, '').replace(/\s*\]\s*$/, '');
+            // Re-run the raw extractor on the unwrapped content prefixed with "{"
+            // so it sees a clean object start even if "[{" was on one line.
+            const unwrappedPairs = extractFzeRawPairs(`[\n${inner}\n]`);
+            if (unwrappedPairs.length > 0 && isFunctionizeFormat(unwrappedPairs)) {
+                return parseFunctionizeCases(unwrappedPairs);
+            }
+        }
+        return null;
+    }
+    // Normalize to array
+    const arr = Array.isArray(data) ? data
+        : data?.testCases ?? data?.cases ?? data?.tests ?? data?.TestCases ?? null;
+    if (!Array.isArray(arr) || arr.length === 0)
+        return null;
+    // Functionize recording format
+    if (isFunctionizeFormat(arr))
+        return parseFunctionizeCases(arr, sourcePlatform);
+    // Check that items look like test cases
+    const first = arr[0];
+    const titleVal = first?.title ?? first?.name ?? first?.summary ?? first?.testName ?? first?.test_name ?? first?.TestCaseName ?? first?.['TC Description'];
+    if (!titleVal)
+        return null;
+    const cases = [];
+    for (const item of arr) {
+        const titleRaw = item.title ?? item.name ?? item.summary ?? item.testName ?? item.test_name ?? item.TestCaseName ?? item['TC Description'] ?? '';
+        if (!titleRaw)
+            continue;
+        const rawSteps = item.steps ?? item.testSteps ?? item.test_steps ?? item.Steps ?? item.stepsList ?? item.actions ?? item.teststeps ?? [];
+        const steps = [];
+        if (Array.isArray(rawSteps)) {
+            for (const s of rawSteps) {
+                if (typeof s === 'string') {
+                    steps.push({ action: s, expected: '' });
+                }
+                else if (s) {
+                    // Check for XPath locator fields and convert to semantic selectors
+                    const rawLocator = s.locator ?? s.selector ?? s.xpath ?? s.target ?? undefined;
+                    let comment;
+                    if (rawLocator && typeof rawLocator === 'string') {
+                        const converted = tryConvertXPathToSemantic(rawLocator);
+                        if (converted) {
+                            comment = `locatorHint: ${converted}`;
+                        }
+                        else {
+                            comment = `xpathFallback: ${rawLocator}`;
+                        }
+                    }
+                    steps.push({
+                        action: String(s.action ?? s.step ?? s.description ?? s.Action ??
+                            s.keyword ?? s.command ?? s.instruction ?? s.label ??
+                            s.name ?? s.stepDescription ?? s.step_description ?? ''),
+                        data: s.data ?? s.testData ?? s.test_data ?? undefined,
+                        expected: String(s.expected ?? s.expectedResult ?? s.expected_result ?? s.Expected ??
+                            s.verification ?? s.assertion ?? s.verify ?? s.outcome ?? ''),
+                        ...(comment ? { comment } : {}),
+                    });
+                }
+            }
+        }
+        if (steps.length === 0) {
+            const exp = String(item.expectedResult ?? item.expected_result ?? item.expected ?? item.ExpectedResult ?? titleRaw);
+            steps.push({ action: 'Execute test case', expected: exp });
+        }
+        const tc = sanitizeParsedCase({
+            ref: (() => {
+                const raw = item.id ?? item.ref ?? item.tcId ?? item.tc_id ?? item['TC_Id #'];
+                if (!raw)
+                    return undefined;
+                return normalizeRef(String(raw), sourcePlatform);
+            })(),
+            title: String(titleRaw),
+            kind: item.type ?? item.kind ?? item.testType ?? item.test_type ?? item.Type ?? 'POSITIVE',
+            priority: item.priority ?? item.Priority ?? 'MEDIUM',
+            preconditions: item.preconditions ?? item.prerequisites ?? item.Preconditions ?? undefined,
+            steps,
+            expectedResult: String(item.expectedResult ?? item.expected_result ?? item.expected ?? item.ExpectedResult ?? titleRaw),
+            tags: Array.isArray(item.tags ?? item.labels) ? (item.tags ?? item.labels) : undefined,
+            section: item.section ?? item.module ?? item.suite ?? item.folder ?? item.component ?? item['Module/Suite'] ?? undefined,
+            testDataInline: parseImportedTestData(item.testData ?? item.test_data ?? item.data ?? item.inputData ?? item.input_data ??
+                item.inputs ?? item.parameters ?? item.params ?? item.variables ?? item.dataset ?? item.dataSet),
+        });
+        if (tc)
+            cases.push(tc);
+    }
+    if (cases.length === 0)
+        return null;
+    return { cases, errors: [] };
+}
+const EDITORIAL_NOTE_RE = /\b(delete this section|keep .* section here|please delete|draft note|todo|tbd)\b/i;
+const REQ_ID_RE = /^(FR|NFR)\d{3}$/i;
+function cleanDocLine(line) {
+    return line.replace(/\f/g, '').replace(/\u200f/g, '').trim();
+}
+function isLikelyHeading(line) {
+    return /^\d+(?:\.\d+)*\s+[A-Z][A-Za-z0-9 &/(),-]+$/.test(line)
+        || /^(Functional Requirements|Non-Functional Requirements|Business Rules|Exception Scenarios)$/i.test(line);
+}
+function normalizeScenarioTitle(raw, max = 78) {
+    const cleaned = raw.replace(/\s+/g, ' ').trim();
+    return cleaned.length <= max ? cleaned : `${cleaned.slice(0, max - 1).trim()}…`;
+}
+function scenarioCategory(text, fallback) {
+    const lower = text.toLowerCase();
+    if (/security|role|permission|access|login|credential|agreement|audit/.test(lower))
+        return 'security-access';
+    if (/batch|overnight|backup|purge|retention|deadline/.test(lower))
+        return 'batch-recovery';
+    if (/dmv|host|connection|download|query|restore|real[- ]time/.test(lower))
+        return 'integration';
+    if (/inventory|plate|sticker|decal|purchase order|reconciliation/.test(lower))
+        return 'inventory';
+    if (/print|document|certificate|tag|bundle report/.test(lower))
+        return 'documents-printing';
+    if (/vin|expiry|expiration|odometer|exemption|fee|tax|validation|block|prevent|reject|required/.test(lower))
+        return 'validation';
+    if (/available|seconds|performance|local functionality|temporarily unavailable/.test(lower))
+        return 'nonfunctional';
+    if (/registration|title|transaction|renewal|backout|fee inquiry|temporary tag|transport tag|dms/.test(lower))
+        return 'transactions';
+    return fallback;
+}
+function suggestedCountFor(text, id) {
+    const lower = text.toLowerCase();
+    if (/end-to-end|full|compliance|real[- ]time|external|dmv|workflow/.test(lower))
+        return 8;
+    if (/transaction|registration|inventory|batch|reconciliation|restore|recovery|2-step|pending/.test(lower))
+        return 6;
+    if (/prevent|block|reject|invalid|boundary|required|role|access|permission/.test(lower))
+        return 4;
+    if (id?.startsWith('NFR'))
+        return 3;
+    return 3;
+}
+function excerptAround(content, re) {
+    const flags = re.flags.includes('i') ? re.flags : `${re.flags}i`;
+    const match = new RegExp(re.source, flags).exec(content);
+    if (!match)
+        return undefined;
+    const start = Math.max(0, content.lastIndexOf('\n', Math.max(0, match.index - 220)));
+    const endRaw = content.indexOf('\n', match.index + match[0].length + 220);
+    const end = endRaw > start ? endRaw : Math.min(content.length, match.index + match[0].length + 220);
+    return content.slice(start, end).split(/\r?\n/).map(cleanDocLine).filter(Boolean).join(' ').slice(0, 500);
+}
+function makeGroundedScenario(args) {
+    const category = args.category ?? scenarioCategory(args.statement, args.id.startsWith('NFR') ? 'nonfunctional' : 'functional');
+    return {
+        id: `src-${args.id.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`,
+        requirementId: args.id,
+        title: normalizeScenarioTitle(`${args.id} ${args.statement.replace(/^The system shall\s+/i, '')}`),
+        description: `Verify source requirement ${args.id}: ${args.statement}`,
+        sourceSection: args.sourceSection,
+        category,
+        sourceExcerpt: args.sourceExcerpt ?? args.statement,
+        suggestedTestCount: suggestedCountFor(args.statement, args.id),
+    };
+}
+const BUSINESS_RULE_PATTERNS = [
+    { id: 'BR-VIN-FORMAT', title: 'VIN format excludes invalid characters by vehicle type', sourceSection: 'Vehicle Data Rules', re: /VIN[\s\S]{0,220}(17|alpha)[\s\S]{0,220}(O,\s*I,\s*U,\s*Q|except letters)/i, category: 'validation', count: 5 },
+    { id: 'BR-MOPED-EXEMPTION', title: 'Moped invalid exemption blocks transmission', sourceSection: 'Tax Exemption Rules', re: /Moped transaction with an exemption type[^.\n]*blocked from transmission/i, category: 'validation', count: 4 },
+    { id: 'BR-TEMP-TAG-ROLES', title: 'Temporary tag roles govern create, reissue, reprint, void, amend, and CVR access', sourceSection: 'Temporary Tag Permission Roles', re: /operator without the Original or Allow CVR role cannot create new registration records/i, category: 'security-access', count: 6 },
+    { id: 'BR-RENEWAL-ELIGIBILITY', title: 'Standard renewal accepts current plate expiration within 1 to 24 months', sourceSection: 'Registration Renewal Rules', re: /current plate expiration date must be within 1 to 24 months/i, category: 'validation', count: 4 },
+    { id: 'BR-RENEWAL-FUTURE-LIMIT', title: 'Future expiry dates beyond 63 months are rejected', sourceSection: 'Registration Renewal Rules', re: /expiry date of more than 63 months/i, category: 'validation', count: 3 },
+    { id: 'BR-PERMANENT-TRAILER-EXPIRY', title: 'Permanent trailer plate series hide renewal expiry fields', sourceSection: 'Registration Renewal Rules', re: /No expiry date applies to series TRLPM and SMTRL/i, category: 'validation', count: 3 },
+    { id: 'BR-RENTAL-TNC', title: 'Rental-TNC registrations lock vehicle use and require TNC date', sourceSection: 'Dealer Type and Vehicle Class Assignment Rules', re: /Rental-TNC registration requires a TNC date/i, category: 'validation', count: 4 },
+    { id: 'BR-MULTI-USE-CUTOFF', title: 'Multi-Use plate inventory ordering is blocked after cutoff', sourceSection: 'Inventory Management Rules', re: /Multi-Use plate ordering cutoff|block ordering of Multi-Use/i, category: 'inventory', count: 3 },
+    { id: 'BR-INVENTORY-BACKOUT', title: 'Backout releases consumed inventory and restores expected status', sourceSection: 'Inventory Management Rules', re: /Backout releases inventory|Inventory status on backout/i, category: 'inventory', count: 4 },
+    { id: 'BR-BACKOUT-REASON', title: 'Backout reason code is mandatory', sourceSection: 'Transaction Lifecycle Rules', re: /Backout reason code is mandatory/i, category: 'validation', count: 3 },
+    { id: 'BR-FI-RETRANSMIT', title: 'F&I station retransmits only pending Temporary Tag or Transport Tag records', sourceSection: 'Transaction Lifecycle Rules', re: /F&I station can only retransmit a pending 2-step record/i, category: 'security-access', count: 4 },
+    { id: 'BR-OVERNIGHT-SEQUENCE', title: 'Overnight batch follows fixed ordered steps and stops on failure', sourceSection: 'Data Integrity Rules', re: /overnight batch runs in this fixed order/i, category: 'batch-recovery', count: 6 },
+    { id: 'BR-OVERNIGHT-RECOVERY-RETRIES', title: 'Overnight recovery retries missing DMV transactions three times', sourceSection: 'Transaction Lifecycle Rules', re: /retrieve each missing transaction from the Virginia DMV up to 3 times/i, category: 'batch-recovery', count: 4 },
+    { id: 'BR-OVERNIGHT-DEADLINE', title: 'Overnight batch deadline and randomized host-load window are enforced', sourceSection: 'Regulatory Compliance Rules', re: /batch completion window closes at 10:15 PM CST/i, category: 'batch-recovery', count: 4 },
+    { id: 'BR-FEE-TABLES', title: 'Fee calculations use only DMV-downloaded fee tables', sourceSection: 'Fee Components', re: /fee calculations shall be based exclusively on Virginia DMV fee tables/i, category: 'integration', count: 4 },
+    { id: 'BR-VSA-ACCEPTANCE', title: 'Virginia State Agreement must be accepted before access', sourceSection: 'Regulatory Compliance Rules', re: /Every operator must accept the Virginia State Agreement/i, category: 'security-access', count: 3 },
+    { id: 'BR-VSA-NAME-LENGTH', title: 'Virginia State Agreement operator name requires at least five characters', sourceSection: 'Regulatory Compliance Rules', re: /name entered on the agreement acceptance screen must be at least 5 characters/i, category: 'validation', count: 3 },
+    { id: 'BR-TEMP-TAG-OWNER-SEX', title: 'Temporary Tag owner sex is required for all owners', sourceSection: 'Ownership and Title Rules', re: /Owner sex is required for Temporary Tag transactions/i, category: 'validation', count: 3 },
+];
+function extractGroundedScenarioCandidates(content) {
+    const lines = content.split(/\r?\n/).map(cleanDocLine);
+    const scenarios = [];
+    let sourceSection = '';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line || EDITORIAL_NOTE_RE.test(line))
+            continue;
+        if (isLikelyHeading(line))
+            sourceSection = line;
+        if (!REQ_ID_RE.test(line))
+            continue;
+        const id = line.toUpperCase();
+        const statementParts = [];
+        for (let j = i + 1; j < Math.min(lines.length, i + 8); j++) {
+            const next = lines[j];
+            if (!next || REQ_ID_RE.test(next) || isLikelyHeading(next))
+                break;
+            if (/^(Req #|Requirement|Rule|Constraint)$/i.test(next) || EDITORIAL_NOTE_RE.test(next))
+                continue;
+            statementParts.push(next);
+            if (/[.!?]$/.test(next) || statementParts.join(' ').length > 220)
+                break;
+        }
+        const statement = statementParts.join(' ').replace(/\s+/g, ' ').trim();
+        if (statement.length < 12)
+            continue;
+        scenarios.push(makeGroundedScenario({
+            id,
+            statement,
+            sourceSection,
+            sourceExcerpt: `${id}: ${statement}`,
+        }));
+    }
+    for (const rule of BUSINESS_RULE_PATTERNS) {
+        const sourceExcerpt = excerptAround(content, rule.re);
+        if (!sourceExcerpt || EDITORIAL_NOTE_RE.test(sourceExcerpt))
+            continue;
+        scenarios.push({
+            id: `src-${rule.id.toLowerCase()}`,
+            requirementId: rule.id,
+            title: normalizeScenarioTitle(`${rule.id} ${rule.title}`),
+            description: `Verify source business rule ${rule.id}: ${rule.title}`,
+            sourceSection: rule.sourceSection,
+            category: rule.category ?? scenarioCategory(rule.title, 'business-rule'),
+            sourceExcerpt,
+            suggestedTestCount: rule.count ?? suggestedCountFor(rule.title, rule.id),
+        });
+    }
+    const byKey = new Map();
+    for (const s of scenarios) {
+        const key = s.requirementId ?? s.title.toLowerCase().replace(/[^a-z0-9]+/g, '');
+        if (!byKey.has(key))
+            byKey.set(key, s);
+    }
+    return [...byKey.values()];
+}
+async function extractScenarios(content, tenantId) {
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(tenantId, 'appBrain').catch(() => null);
+    if (!llmCfg)
+        throw new Error('No LLM provider configured. Please set up an AI model in Workspace → Settings → AI Model.');
+    const SCENARIOS_DEFAULT = `You are a senior QA analyst. Extract ALL testable scenarios from the document.
+A "scenario" is a high-level feature, user story, requirement, or acceptance criterion that needs to be tested.
+Do NOT generate individual test steps — identify what needs testing at a feature/behavior level.
+
+Rules:
+- Each scenario represents one coherent, non-overlapping feature or behavior
+- "title" should be short and descriptive (under 80 chars)
+- "description" explains what to verify (1-3 sentences)
+- "sourceSection" is the heading, section title, or slide number where found (omit if not identifiable)
+- "requirementId" is the explicit source ID when present (FR001, NFR002, or a named business rule)
+- "sourceExcerpt" is the short exact source text that justifies the scenario
+- "category" classifies the scenario, e.g. transactions, inventory, validation, integration, security-access, batch-recovery, nonfunctional
+- "suggestedTestCount" is your estimate of how many test cases this warrants (1-20); use higher counts for complex transactional flows
+- Return as many scenarios as the document warrants — be exhaustive, not selective
+
+CRITICAL — you MUST cover ALL of these categories if present in the document:
+1. Happy-path functional flows (each major feature gets its own scenario)
+2. Error handling and failure recovery (network drop, host timeout, mid-transaction failure, printer offline)
+3. Data validation (format checks, boundary values, invalid input rejection)
+4. Security and access control (unauthorized access, privilege escalation, session management)
+5. Non-functional requirements (performance thresholds, availability SLAs, batch processing)
+6. Integration points (external system connections, real-time data exchange, error response handling)
+7. Compliance and audit (audit trails, regulatory requirements, mandatory logging)
+8. Edge cases per feature (concurrent users, special categories, exemptions, overrides)
+
+DEDUPLICATION — do NOT create overlapping scenarios:
+- If a document has both a high-level summary section AND a detailed requirements section covering the same feature, produce ONE scenario that references both, not two separate scenarios
+- Merge scenarios that differ only in section number or heading label but test the same behavior
+- Never produce two scenarios with >50% overlap in what they test
+
+suggestedTestCount guidance by complexity:
+- Simple CRUD or status check: 3-5 tests
+- Transaction with validation: 5-8 tests
+- Multi-step workflow with error paths: 8-12 tests
+- Complex integration with external system: 10-15 tests
+- Full end-to-end flow with compliance requirements: 12-20 tests`;
+    const system = await (0, core_1.getAgentPrompt)('test-import-scenarios', undefined, tenantId) ?? SCENARIOS_DEFAULT;
+    const schema = {
+        type: 'object',
+        properties: {
+            scenarios: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string' },
+                        description: { type: 'string' },
+                        sourceSection: { type: 'string' },
+                        requirementId: { type: 'string' },
+                        category: { type: 'string' },
+                        sourceExcerpt: { type: 'string' },
+                        suggestedTestCount: { type: 'number' },
+                    },
+                    required: ['title', 'description', 'suggestedTestCount'],
+                },
+            },
+        },
+        required: ['scenarios'],
+    };
+    const truncated = content.length > 48000 ? content.slice(0, 48000) : content;
+    const user = `Extract ALL testable scenarios from this document. Be exhaustive — cover functional flows, error paths, validation, security, non-functional requirements, and compliance:\n\n${truncated}`;
+    const groundedScenarios = extractGroundedScenarioCandidates(content);
+    try {
+        const seed = (0, llm_js_1.deterministicSeed)(`extract-scenarios:${content.slice(0, 2000)}`);
+        const { text } = await (0, llm_js_1.askTracked)(system, user, llmCfg, 8192, schema, { temperature: 0, seed });
+        const parsed = JSON.parse(text);
+        const rawScenarios = parsed.scenarios ?? [];
+        // Dedup by normalized title — remove scenarios whose title is >70% similar to an earlier one
+        const seen = [];
+        const isRedundant = (title) => {
+            const normalized = title.toLowerCase().replace(/[^a-z0-9 ]/g, '').trim();
+            const words = new Set(normalized.split(/\s+/).filter((w) => w.length > 3));
+            for (const s of seen) {
+                const sWords = new Set(s.split(/\s+/).filter((w) => w.length > 3));
+                const intersection = [...words].filter((w) => sWords.has(w)).length;
+                const union = new Set([...words, ...sWords]).size;
+                if (union > 0 && intersection / union >= 0.7)
+                    return true;
+            }
+            return false;
+        };
+        const aiScenarios = rawScenarios
+            .map((s, i) => ({
+            id: `sc-${i}`,
+            title: String(s.title ?? '').trim(),
+            description: String(s.description ?? '').trim(),
+            sourceSection: s.sourceSection ? String(s.sourceSection).trim() : undefined,
+            requirementId: s.requirementId ? String(s.requirementId).trim().toUpperCase() : undefined,
+            category: s.category ? String(s.category).trim() : undefined,
+            sourceExcerpt: s.sourceExcerpt ? String(s.sourceExcerpt).trim().slice(0, 500) : undefined,
+            suggestedTestCount: Math.max(1, Math.min(20, Number(s.suggestedTestCount) || 3)),
+        }))
+            .filter((s) => s.title)
+            .filter((s) => {
+            if (s.requirementId)
+                return true;
+            const normalized = s.title.toLowerCase().replace(/[^a-z0-9 ]/g, '').trim();
+            if (isRedundant(normalized))
+                return false;
+            seen.push(normalized);
+            return true;
+        });
+        const scenarios = [];
+        const coveredReqIds = new Set();
+        const seenTitles = new Set();
+        for (const s of [...groundedScenarios, ...aiScenarios]) {
+            const reqId = s.requirementId?.trim();
+            if (reqId) {
+                if (coveredReqIds.has(reqId))
+                    continue;
+                coveredReqIds.add(reqId);
+            }
+            else {
+                const titleKey = s.title.toLowerCase().replace(/[^a-z0-9]+/g, '');
+                if (seenTitles.has(titleKey))
+                    continue;
+                seenTitles.add(titleKey);
+            }
+            scenarios.push(s);
+        }
+        return { scenarios, errors: [] };
+    }
+    catch (err) {
+        if (groundedScenarios.length > 0) {
+            return {
+                scenarios: groundedScenarios,
+                errors: [`AI scenario extraction failed; used deterministic BRD coverage instead: ${err?.message ?? String(err)}`],
+            };
+        }
+        throw new Error(`Scenario extraction failed: ${err?.message ?? String(err)}`);
+    }
+}
+// ─── Selenium locator injection ───────────────────────────────────────────────
+/**
+ * Parse a Selenium Python script and extract a map of action descriptions → Playwright locators.
+ * Used to annotate FZE test case steps with real locators from matched Selenium recordings.
+ */
+function buildSeleniumHints(pyContent) {
+    const hints = new Map();
+    if (!pyContent)
+        return hints;
+    const lines = pyContent.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Extract send_keys calls: driver.find_element(By.XPATH, "...").send_keys("value")
+        const sendKeysMatch = trimmed.match(/find_element\s*\(\s*By\.XPATH\s*,\s*["']([^"']+)["']\s*\)\.send_keys\s*\(\s*["']?([^"')]+)["']?\s*\)/);
+        if (sendKeysMatch) {
+            const [, xpath, value] = sendKeysMatch;
+            const locator = xpathToPlaywright(xpath);
+            if (locator && value && value.length < 100) {
+                hints.set(`type:${value.toLowerCase().trim().slice(0, 40)}`, locator);
+            }
+            continue;
+        }
+        // Extract click calls: driver.find_element(By.XPATH, "...").click()
+        const clickMatch = trimmed.match(/find_element\s*\(\s*By\.XPATH\s*,\s*["']([^"']+)["']\s*\)\.click\s*\(\s*\)/);
+        if (clickMatch) {
+            const [, xpath] = clickMatch;
+            const locator = xpathToPlaywright(xpath);
+            if (locator) {
+                const textMatch = xpath.match(/text\(\)\s*=\s*["']([^"']+)["']/);
+                const ariaMatch = xpath.match(/@aria-label\s*=\s*["']([^"']+)["']/);
+                const idMatch = xpath.match(/@id\s*=\s*["']([^"']+)["']/);
+                const key = textMatch?.[1] || ariaMatch?.[1] || idMatch?.[1] || '';
+                if (key)
+                    hints.set(`click:${key.toLowerCase().trim().slice(0, 40)}`, locator);
+            }
+            continue;
+        }
+        // Extract switch_to.frame calls
+        const frameMatch = trimmed.match(/switch_to\.frame\s*\(\s*["']?([^"')]+)["']?\s*\)/);
+        if (frameMatch) {
+            const [, frame] = frameMatch;
+            hints.set(`switch:frame:${frame.trim().slice(0, 40)}`, `iframe[name="${frame.trim()}"]`);
+        }
+    }
+    return hints;
+}
+// Convert common XPath patterns to Playwright locators
+function xpathToPlaywright(xpath) {
+    // aria-label
+    const ariaMatch = xpath.match(/@aria-label\s*=\s*["']([^"']+)["']/);
+    if (ariaMatch)
+        return `[aria-label="${ariaMatch[1]}"]`;
+    // text() contains or equals
+    const textContains = xpath.match(/contains\s*\(\s*text\s*\(\s*\)\s*,\s*["']([^"']+)["']\s*\)/);
+    if (textContains)
+        return `text=${textContains[1]}`;
+    const textEq = xpath.match(/text\(\)\s*=\s*["']([^"']+)["']/);
+    if (textEq)
+        return `text="${textEq[1]}"`;
+    // id
+    const idMatch = xpath.match(/@id\s*=\s*["']([^"']+)["']/);
+    if (idMatch)
+        return `#${idMatch[1]}`;
+    // data-testid
+    const testidMatch = xpath.match(/@data-testid\s*=\s*["']([^"']+)["']/);
+    if (testidMatch)
+        return `[data-testid="${testidMatch[1]}"]`;
+    // placeholder
+    const placeholderMatch = xpath.match(/@placeholder\s*=\s*["']([^"']+)["']/);
+    if (placeholderMatch)
+        return `[placeholder="${placeholderMatch[1]}"]`;
+    // name attribute
+    const nameMatch = xpath.match(/@name\s*=\s*["']([^"']+)["']/);
+    if (nameMatch)
+        return `[name="${nameMatch[1]}"]`;
+    // Fallback to xpath locator (Playwright supports these)
+    if (xpath.length < 200)
+        return `xpath=${xpath}`;
+    return null;
+}
+/**
+ * Annotate parsed test case steps with Playwright locators from Selenium hints.
+ * Matches steps by normalized action text against the hint map.
+ * Adds locatorHint comment to matched steps.
+ */
+function annotateWithSeleniumHints(cases, hints) {
+    if (hints.size === 0)
+        return cases;
+    return cases.map(tc => ({
+        ...tc,
+        steps: tc.steps.map(step => {
+            const actionLow = step.action.toLowerCase();
+            // Try to match type steps: "Enter {field}: '{value}'"
+            const enterMatch = step.action.match(/^Enter .+?:\s*['""]?(.+?)['""]?\s*$/i);
+            if (enterMatch) {
+                const value = enterMatch[1].replace(/^\{\{.+\}\}$/, '').trim().slice(0, 40).toLowerCase();
+                const locator = value ? hints.get(`type:${value}`) : undefined;
+                if (locator && !step.comment) {
+                    return { ...step, comment: `locatorHint: ${locator}` };
+                }
+            }
+            // Try to match click steps: "Click {element}: '{text}'"
+            const clickMatch = step.action.match(/^Click .+?:\s*['""]?(.+?)['""]?\s*$/i);
+            if (clickMatch) {
+                const label = clickMatch[1].trim().slice(0, 40).toLowerCase();
+                const locator = hints.get(`click:${label}`);
+                if (locator && !step.comment) {
+                    return { ...step, comment: `locatorHint: ${locator}` };
+                }
+            }
+            // Match context switch steps
+            if (actionLow.startsWith('switch to context')) {
+                const frameMatch = step.action.match(/iframe\[name="([^"]+)"\]/);
+                if (frameMatch) {
+                    const locator = hints.get(`switch:frame:${frameMatch[1].toLowerCase()}`);
+                    if (locator && !step.comment) {
+                        return { ...step, comment: `locatorHint: ${locator}` };
+                    }
+                }
+            }
+            return step;
+        }),
+    }));
+}