@tayo-dev/rtl 1.3.1 → 1.4.1

package/dist/cli/commands/generate.js

@@ -1,14 +1,12 @@
 /**
  * Generate command
- * Full pipeline: parse → validate → generate → write
- * Converts Recorder exports into React Testing Library test files.
+ * Internal runtime-only generation pipeline for Testing Library Recorder JS exports.
  */
 import { Command } from 'commander';
 import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { basename, dirname, join, resolve } from 'node:path';
 import { cwd } from 'node:process';
 import pc from 'picocolors';
-import { generateTest } from '../../core/generator.js';
 import { writeTestFile } from '../../core/writer.js';
 import { captureVisualState, resolveSelector, } from '../../core/resolver.js';
 import { scoreGeneratedTest } from '../../core/scorer.js';
@@ -21,26 +19,106 @@ import { generateTestFromGroups, emitQuerySummary } from '../../core/generator.j
 import { loadInput } from '../../core/input-loader.js';
 import { normalizeJsBaseline } from '../../core/baseline-normalizer.js';
 import { planJsSuite } from '../../core/suite-planner.js';
+const EMPTY_MARKER_COVERAGE = {
+    detected: 0,
+    emitted: 0,
+    unresolved: 0,
+};
+const UNRESOLVED_MARKER_REASON_GUIDANCE = {
+    'missing-marker-candidate': 'Semantic marker candidate metadata is missing. Re-record or keep marker metadata intact.',
+    'missing-anchor': 'Marker has no reliable anchor step. Re-record with marker near the intended assertion moment.',
+    'missing-query': 'Recorder evidence is missing an accessible query. Capture a clearer role/name or visible text.',
+    'unsupported-proof-subject': 'Marker proof subject is unsupported for safe RTL conversion. Use role/name or visible text proof.',
+    'ambiguous-field-context': 'Field context is ambiguous. Capture a single, specific field label or value target.',
+    'unsupported-field-context': 'Field context could not map to a trusted RTL field query. Record a clearer label/placeholder.',
+    'generic-container': 'Marker points to a generic container. Capture the concrete user-facing element instead.',
+    'css-only-evidence': 'Marker is backed only by CSS-like evidence. Capture semantic role/name or visible text evidence.',
+    'icon-only-target': 'Marker target is icon-only and ambiguous. Capture surrounding accessible text context.',
+    'hidden-evidence': 'Marker evidence depends on hidden/implementation selectors. Capture user-visible evidence instead.',
+};
 function deriveOutputPath(inputPath) {
     const dir = dirname(inputPath);
-    const name = basename(inputPath).replace(/\.(json|[cm]?[jt]sx?)$/, '');
+    const name = basename(inputPath).replace(/\.[cm]?[jt]sx?$/, '');
     return join(dir, `${name}.test.tsx`);
 }
 function logScore(scoreResult) {
-    console.log(pc.dim('[taro]') +
+    const markerCoverageSummary = `markers: detected=${scoreResult.markerCoverage.detected}, ` +
+        `emitted=${scoreResult.markerCoverage.emitted}, ` +
+        `unresolved=${scoreResult.markerCoverage.unresolved}`;
+    console.log(pc.dim('[tayo]') +
         ` Score: ${scoreResult.total}/100 (${scoreResult.grade}) — ` +
         `query: ${scoreResult.dimensions.queryQuality}, ` +
         `assertions: ${scoreResult.dimensions.assertionSpecificity}, ` +
         `structure: ${scoreResult.dimensions.testStructure}, ` +
-        `boundary: ${scoreResult.dimensions.boundaryIsolation}`);
+        `boundary: ${scoreResult.dimensions.boundaryIsolation}, ` +
+        markerCoverageSummary);
+}
+function emitMarkerCoverageSection(scoreResult) {
+    const gateStatus = scoreResult.markerQualityGate.failing ? pc.red('FAIL') : pc.green('PASS');
+    console.log(pc.dim('[tayo]') + ' Marker coverage:');
+    console.log(pc.dim('[tayo]') + `   detected: ${scoreResult.markerCoverage.detected}`);
+    console.log(pc.dim('[tayo]') + `   emitted: ${scoreResult.markerCoverage.emitted}`);
+    console.log(pc.dim('[tayo]') + `   unresolved: ${scoreResult.markerCoverage.unresolved}`);
+    console.log(pc.dim('[tayo]') +
+        `   QUAL-02 gate: ${gateStatus} (${scoreResult.markerQualityGate.reason})`);
+    if (scoreResult.markerQualityGate.failing) {
+        console.error(pc.red(`[tayo] QUAL-02 FAIL: ${scoreResult.markerQualityGate.message}`));
+    }
+}
+function normalizeUnresolvedMarkerHint(marker) {
+    const hint = marker.proofText ?? marker.target ?? marker.query?.raw ?? marker.selector?.selector;
+    const normalized = hint?.replace(/\s+/g, ' ').trim();
+    return normalized && normalized.length > 0 ? normalized : 'none';
+}
+function formatUnresolvedMarkerLine(marker) {
+    const line = marker.line ?? marker.sourceContext.line;
+    return Number.isFinite(line) ? String(line) : 'unknown';
+}
+function formatUnresolvedMarkerWarning(marker) {
+    const line = formatUnresolvedMarkerLine(marker);
+    const hint = normalizeUnresolvedMarkerHint(marker);
+    const guidance = UNRESOLVED_MARKER_REASON_GUIDANCE[marker.reason];
+    return (`MKR-03 unresolved-marker marker=${marker.markerStepId} ` +
+        `line: ${line} reason=${marker.reason} ` +
+        `detail="${guidance}" hint="${hint}"`);
+}
+function collectUnresolvedMarkerAssertions(suitePlan) {
+    const seenMarkerStepIds = new Set();
+    const unresolvedMarkers = [];
+    for (const scenario of suitePlan.scenarios) {
+        for (const unresolvedMarker of scenario.unresolvedMarkerAssertions ?? []) {
+            if (seenMarkerStepIds.has(unresolvedMarker.markerStepId)) {
+                continue;
+            }
+            seenMarkerStepIds.add(unresolvedMarker.markerStepId);
+            unresolvedMarkers.push(unresolvedMarker);
+        }
+    }
+    return unresolvedMarkers;
+}
+function emitUnresolvedMarkerWarnings(suitePlan) {
+    if (!suitePlan) {
+        return;
+    }
+    const unresolvedMarkers = collectUnresolvedMarkerAssertions(suitePlan);
+    for (const unresolvedMarker of unresolvedMarkers) {
+        console.warn(pc.yellow(`[tayo] ${formatUnresolvedMarkerWarning(unresolvedMarker)}`));
+    }
+}
+function enforceMarkerGateExit(scoreResult) {
+    if (!scoreResult.markerQualityGate.failing) {
+        return;
+    }
+    process.exitCode = 1;
+    console.error(pc.red('[tayo] Exiting with code 1: QUAL-02 gate failed after generation.'));
 }
 function emitLowConfidenceBanner(scoreResult) {
     if (!scoreResult.requiresReview) {
         return;
     }
-    console.warn(pc.yellow(`[taro] Manual review required — this generated test is still a draft (${scoreResult.total}/100, ${scoreResult.grade}).`));
+    console.warn(pc.yellow(`[tayo] Manual review required — this generated test is still a draft (${scoreResult.total}/100, ${scoreResult.grade}).`));
     if (scoreResult.blockers.length > 0) {
-        console.warn(pc.yellow(`[taro] Top blockers: ${scoreResult.blockers.join(' | ')}`));
+        console.warn(pc.yellow(`[tayo] Top blockers: ${scoreResult.blockers.join(' | ')}`));
     }
 }
 function emitScoreHints(scoreResult, queryResults = [], boundaryIssues = analyzeBoundaryIsolation('')) {
@@ -48,18 +126,18 @@ function emitScoreHints(scoreResult, queryResults = [], boundaryIssues = analyze
         const testIdCount = queryResults.filter((queryResult) => {
             return queryResult.method === 'getByTestId';
         }).length;
-        console.log(pc.yellow(`[taro] Tip: ${testIdCount} getByTestId queries — consider adding aria-label`));
+        console.log(pc.yellow(`[tayo] Tip: ${testIdCount} getByTestId queries — consider adding aria-label`));
     }
     if (scoreResult.dimensions.assertionSpecificity < 60) {
-        console.log(pc.yellow('[taro] Tip: Add specific matchers like toHaveValue() for better assertions'));
+        console.log(pc.yellow('[tayo] Tip: Add specific matchers like toHaveValue() for better assertions'));
     }
     if (scoreResult.dimensions.testStructure < 60) {
-        console.log(pc.yellow('[taro] Tip: Split into multiple it() blocks for better test organization'));
+        console.log(pc.yellow('[tayo] Tip: Split into multiple it() blocks for better test organization'));
     }
     if (scoreResult.dimensions.boundaryIsolation < 60) {
         for (const issue of boundaryIssues) {
-            console.warn(pc.yellow(`[taro] Boundary: ${issue.message}`));
-            console.warn(pc.yellow(`[taro] Tip: ${issue.suggestion}`));
+            console.warn(pc.yellow(`[tayo] Boundary: ${issue.message}`));
+            console.warn(pc.yellow(`[tayo] Tip: ${issue.suggestion}`));
         }
     }
 }
@@ -69,6 +147,12 @@ function summarizeCleanup(analyzedRecording) {
     if (diagnostics.removedRedundantClicks > 0) {
         parts.push(`${diagnostics.removedRedundantClicks} redundant click(s)`);
     }
+    if ((diagnostics.preservedSemanticMarkers ?? 0) > 0) {
+        parts.push(`${diagnostics.preservedSemanticMarkers} preserved semantic marker(s)`);
+    }
+    if ((diagnostics.unresolvedSemanticMarkers ?? 0) > 0) {
+        parts.push(`${diagnostics.unresolvedSemanticMarkers} unresolved semantic marker(s)`);
+    }
     if (diagnostics.removedDoubleClickNoise > 0) {
         parts.push(`${diagnostics.removedDoubleClickNoise} dblClick noise event(s)`);
     }
@@ -81,7 +165,69 @@ function summarizeCleanup(analyzedRecording) {
     if (parts.length === 0) {
         return;
     }
-    console.log(pc.dim('[taro]') + ` Recording cleanup: ${parts.join(', ')}`);
+    console.log(pc.dim('[tayo]') + ` Recording cleanup: ${parts.join(', ')}`);
+}
+function countPlannedScenarioMarkers(scenarios) {
+    return scenarios.reduce((totals, scenario) => ({
+        emitted: totals.emitted + (scenario.markerAssertions?.length ?? 0),
+        unresolved: totals.unresolved + (scenario.unresolvedMarkerAssertions?.length ?? 0),
+    }), {
+        emitted: 0,
+        unresolved: 0,
+    });
+}
+function buildMarkerCoverageSummary(params) {
+    const { analyzedRecording, suitePlan } = params;
+    const preservedMarkers = analyzedRecording.diagnostics.preservedSemanticMarkers ?? 0;
+    const diagnosticUnresolvedMarkers = analyzedRecording.diagnostics.unresolvedSemanticMarkers ?? 0;
+    if (!suitePlan) {
+        return {
+            detected: preservedMarkers + diagnosticUnresolvedMarkers,
+            emitted: 0,
+            unresolved: diagnosticUnresolvedMarkers,
+        };
+    }
+    const plannedMarkerTotals = countPlannedScenarioMarkers(suitePlan.scenarios);
+    const unresolved = plannedMarkerTotals.unresolved;
+    const detected = Math.max(preservedMarkers + unresolved, plannedMarkerTotals.emitted + unresolved);
+    return {
+        detected,
+        emitted: plannedMarkerTotals.emitted,
+        unresolved,
+    };
+}
+function mergeAnalyzedStepState(recording, analyzedRecording) {
+    const analyzedStepsById = new Map(analyzedRecording.steps
+        .filter((step) => Boolean(step.id))
+        .map((step) => [step.id, step]));
+    return {
+        ...recording,
+        steps: recording.steps.map((step) => {
+            if (!step.id) {
+                return step;
+            }
+            const analyzedStep = analyzedStepsById.get(step.id);
+            if (!analyzedStep) {
+                return step;
+            }
+            return {
+                ...step,
+                ...(analyzedStep.semanticMarkerCandidate
+                    ? { semanticMarkerCandidate: analyzedStep.semanticMarkerCandidate }
+                    : {}),
+                ...(analyzedStep.semanticMarkerLink
+                    ? { semanticMarkerLink: analyzedStep.semanticMarkerLink }
+                    : {}),
+                ...(analyzedStep.unresolvedSemanticMarker
+                    ? { unresolvedSemanticMarker: analyzedStep.unresolvedSemanticMarker }
+                    : {}),
+                metadata: {
+                    ...step.metadata,
+                    ...analyzedStep.metadata,
+                },
+            };
+        }),
+    };
 }
 function toItGroups(analyzedRecording, fallbackTitle) {
     if (analyzedRecording.intentGroups.length > 0) {
@@ -164,6 +310,37 @@ function rehydrateSuitePlan(plan, steps) {
         })),
     };
 }
+function isSemanticMarkerStep(step) {
+    return Boolean(step.semanticMarkerLink || step.unresolvedSemanticMarker);
+}
+function stripSemanticMarkerStepsFromItGroups(itGroups) {
+    return itGroups
+        .map((group) => ({
+        ...group,
+        steps: group.steps.filter((step) => !isSemanticMarkerStep(step)),
+    }))
+        .filter((group) => group.steps.length > 0);
+}
+function stripSemanticMarkerStepsFromHelpers(helpers) {
+    return helpers
+        .map((helper) => ({
+        ...helper,
+        steps: helper.steps.filter((step) => !isSemanticMarkerStep(step)),
+    }))
+        .filter((helper) => helper.steps.length > 0);
+}
+function stripSemanticMarkerStepsFromScenarios(scenarios, helpers) {
+    const helperNames = new Set(helpers.map((helper) => helper.name));
+    return scenarios
+        .map((scenario) => ({
+        ...scenario,
+        steps: scenario.steps.filter((step) => !isSemanticMarkerStep(step)),
+        helperRefs: scenario.helperRefs.filter((helperRef) => helperNames.has(helperRef)),
+    }))
+        .filter((scenario) => scenario.steps.length > 0 ||
+        scenario.helperRefs.length > 0 ||
+        (scenario.markerAssertions?.length ?? 0) > 0);
+}
 function dedupeQueryResults(queryResults) {
     const seen = new Set();
     return queryResults.filter((queryResult) => {
@@ -189,7 +366,7 @@ function summarizeVisualState(visualState) {
     if (visualState.screenshotPath) {
         parts.push(`screenshot=${visualState.screenshotPath}`);
     }
-    console.log(pc.dim('[taro]') + ` Visual state: ${parts.join(', ')}`);
+    console.log(pc.dim('[tayo]') + ` Visual state: ${parts.join(', ')}`);
 }
 function summarizeMockAnalysis(mockAnalysis) {
     if (!mockAnalysis) {
@@ -208,25 +385,25 @@ function summarizeMockAnalysis(mockAnalysis) {
     if (parts.length === 0) {
         return;
     }
-    console.log(pc.dim('[taro]') + ` Mock analysis: ${parts.join(', ')}`);
+    console.log(pc.dim('[tayo]') + ` Mock analysis: ${parts.join(', ')}`);
     const topRecommendation = mockAnalysis.recommendations[0];
     if (topRecommendation) {
-        console.log(pc.dim('[taro]') +
+        console.log(pc.dim('[tayo]') +
             ` Mock hint: ${topRecommendation.kind} ${topRecommendation.target} (${topRecommendation.count} file(s))`);
     }
     const topLifecycle = mockAnalysis.mutationLifecycles[0];
     if (topLifecycle) {
-        console.log(pc.dim('[taro]') +
+        console.log(pc.dim('[tayo]') +
             ` Mutation lifecycle: ${topLifecycle.stages.join(' -> ')} in ${topLifecycle.file}`);
     }
     const topWarning = mockAnalysis.instabilityWarnings[0];
     if (topWarning) {
-        console.warn(pc.yellow(`[taro] Mock stability: ${topWarning.reason} (${topWarning.file})`));
+        console.warn(pc.yellow(`[tayo] Mock stability: ${topWarning.reason} (${topWarning.file})`));
     }
 }
 function summarizeBoundaryWarnings(warnings) {
     for (const warning of warnings) {
-        console.warn(pc.yellow(`[taro] Boundary: ${warning}`));
+        console.warn(pc.yellow(`[tayo] Boundary: ${warning}`));
     }
 }
 function tokenizeSuiteHint(value) {
@@ -288,7 +465,7 @@ function applyRepoRenderTarget(suitePlan, renderTarget) {
             resolvedTarget: renderTarget.symbol,
             confidence: suitePlan.renderBoundary.confidence === 'low' ? 'medium' : suitePlan.renderBoundary.confidence,
         },
-        warnings: suitePlan.warnings.filter((warning) => !warning.includes('Taro could not resolve the exact render target from repo context') &&
+        warnings: suitePlan.warnings.filter((warning) => !warning.includes('Tayo could not resolve the exact render target from repo context') &&
             !warning.includes('Prefer a repo-local module/container render boundary')),
     };
 }
@@ -313,7 +490,7 @@ async function resolveJsGeneration(recording, itGroups) {
         .map((step) => [step.id, step]));
     const updatedSteps = new Map();
     if (selectorGroups.size > 0 && recording.url) {
-        console.log(pc.dim('[taro]') +
+        console.log(pc.dim('[tayo]') +
             ` Resolving ${baseline.selectors.length} selector(s) via Playwright...`);
     }
     for (const [stepId, selectors] of selectorGroups) {
@@ -373,7 +550,7 @@ async function resolveJsGeneration(recording, itGroups) {
 }
 function summarizeSelectorWarnings(warnings) {
     for (const warning of warnings) {
-        console.warn(pc.yellow(`[taro] ${warning}`));
+        console.warn(pc.yellow(`[tayo] ${warning}`));
     }
 }
 async function maybeCaptureVisualState(params) {
@@ -382,7 +559,7 @@ async function maybeCaptureVisualState(params) {
         return null;
     }
     const candidates = findVisualCaptureCandidates(analyzedRecording);
-    const visualDir = join(projectRoot, '.taro', 'visual');
+    const visualDir = join(projectRoot, '.tayo', 'visual');
     if (candidates.length > 0) {
         await mkdir(visualDir, { recursive: true });
         return captureVisualState(url, {
@@ -410,7 +587,7 @@ async function maybeAnalyzeMocks(projectRoot) {
     }
 }
 async function appendHistoryEntry(projectRoot, historyEntry) {
-    const taroDir = join(projectRoot, '.taro');
+    const taroDir = join(projectRoot, '.tayo');
     await mkdir(taroDir, { recursive: true });
     const historyPath = join(taroDir, 'history.json');
     let history = [];
@@ -429,12 +606,12 @@ async function finalizeGeneratedOutput(params) {
     const { code, outputPath, projectRoot, recordingFile, scoreResult } = params;
     const verification = verifySyntax(code, outputPath);
     if (!verification.valid) {
-        console.error(pc.red('[taro] Error: Post-write verification failed'));
+        console.error(pc.red('[tayo] Error: Post-write verification failed'));
         console.error(pc.red(`  ${verification.error}`));
-        console.error(pc.red('  This is a Taro bug. Please report it.'));
+        console.error(pc.red('  This is a Tayo bug. Please report it.'));
         process.exit(1);
     }
-    console.log(pc.green('[taro] ✓ post-write verified'));
+    console.log(pc.green('[tayo] ✓ post-write verified'));
     await appendHistoryEntry(projectRoot, {
         timestamp: new Date().toISOString(),
         recordingFile,
@@ -451,14 +628,11 @@ async function finalizeGeneratedOutput(params) {
     }
 }
 export function createGenerateCommand() {
-    const generate = new Command('generate');
+    const generate = new Command('__generate');
     generate
-        .description('Generate RTL test from Recorder JS or Chrome Recorder JSON export')
-        .argument('<file>', 'Path to the recorder export file (.js or .json)')
-        .option('-o, --output <path>', 'Output file path for the generated test')
-        .option('-d, --dry-run', 'Preview the generated test without writing to disk', false)
-        .option('-f, --force', 'Overwrite existing test file', false)
-        .action(async (file, options) => {
+        .description('Internal runtime-only generator for Testing Library Recorder JS exports')
+        .argument('<file>', 'Path to the recorder export file (.js)')
+        .action(async (file) => {
         const filePath = resolve(file);
         const projectRoot = cwd();
         // 1. Verify file is accessible
@@ -477,23 +651,18 @@ export function createGenerateCommand() {
             console.error(pc.red('Error:') + ` Failed to parse recording: ${pc.bold(filePath)}\n${String(err)}`);
             process.exit(1);
         }
-        const normalizedRecording = parsedInput.source === 'js' ? normalizeJsBaseline(parsedInput) : parsedInput.recording;
-        let conventions = undefined;
-        let repoRenderTargets = [];
-        if (parsedInput.source === 'js') {
-            conventions = await readConventions(projectRoot);
-            if (!conventions) {
-                console.log(pc.dim('[taro]') + ' Scanning project conventions...');
-                conventions = await scanConventions(projectRoot);
-            }
-            repoRenderTargets = await discoverRepoRenderTargets(projectRoot);
+        const normalizedRecording = normalizeJsBaseline(parsedInput);
+        let conventions = await readConventions(projectRoot);
+        if (!conventions) {
+            console.log(pc.dim('[tayo]') + ' Scanning project conventions...');
+            conventions = await scanConventions(projectRoot);
         }
+        const repoRenderTargets = await discoverRepoRenderTargets(projectRoot);
         console.log(pc.green('Parsed:') +
             ` ${pc.bold(normalizedRecording.title)} — ${normalizedRecording.steps.length} steps` +
-            (parsedInput.source === 'js'
-                ? `, ${normalizedRecording.baseline?.itGroups.length ?? 0} test group(s)`
-                : ''));
+            `, ${normalizedRecording.baseline?.itGroups.length ?? 0} test group(s)`);
         const analyzedRecording = analyzeRecording(normalizedRecording);
+        const markerAwareRecording = mergeAnalyzedStepState(normalizedRecording, analyzedRecording);
         summarizeCleanup(analyzedRecording);
         const visualState = await maybeCaptureVisualState({
             analyzedRecording,
@@ -504,79 +673,72 @@ export function createGenerateCommand() {
         summarizeVisualState(visualState);
         const mockAnalysis = await maybeAnalyzeMocks(projectRoot);
         summarizeMockAnalysis(mockAnalysis);
-        const outputPath = options.output ?? deriveOutputPath(filePath);
-        const rawJsSuitePlan = parsedInput.source === 'js'
-            ? planJsSuite({
-                recording: normalizedRecording,
-                analyzedRecording,
-                mockAnalysis,
-                fallbackTitle: normalizedRecording.title,
-            })
-            : null;
-        const repoRenderTarget = parsedInput.source === 'js' && rawJsSuitePlan
-            ? resolveRepoRenderTarget({
-                candidates: repoRenderTargets,
-                recording: normalizedRecording,
-                mockAnalysis,
-                suitePlan: rawJsSuitePlan,
-            })
-            : null;
+        const outputPath = deriveOutputPath(filePath);
+        const rawJsSuitePlan = planJsSuite({
+            recording: markerAwareRecording,
+            analyzedRecording,
+            mockAnalysis,
+            fallbackTitle: normalizedRecording.title,
+        });
+        const repoRenderTarget = resolveRepoRenderTarget({
+            candidates: repoRenderTargets,
+            recording: normalizedRecording,
+            mockAnalysis,
+            suitePlan: rawJsSuitePlan,
+        });
         const jsSuitePlan = rawJsSuitePlan
             ? applyRepoRenderTarget(rawJsSuitePlan, repoRenderTarget)
             : null;
         if (jsSuitePlan) {
             summarizeBoundaryWarnings(jsSuitePlan.warnings);
         }
-        const resolvedJsGeneration = parsedInput.source === 'js'
-            ? await resolveJsGeneration(normalizedRecording, jsSuitePlan?.itGroups ?? toItGroups(analyzedRecording, normalizedRecording.title))
-            : null;
+        const resolvedJsGeneration = await resolveJsGeneration(markerAwareRecording, jsSuitePlan?.itGroups ?? toItGroups(analyzedRecording, normalizedRecording.title));
         if (resolvedJsGeneration) {
             summarizeSelectorWarnings(resolvedJsGeneration.warnings);
         }
-        const hydratedSuitePlan = parsedInput.source === 'js' && jsSuitePlan
-            ? rehydrateSuitePlan(jsSuitePlan, resolvedJsGeneration?.recording.steps ?? normalizedRecording.steps)
+        const hydratedSuitePlan = jsSuitePlan
+            ? rehydrateSuitePlan(jsSuitePlan, resolvedJsGeneration?.recording.steps ?? markerAwareRecording.steps)
             : jsSuitePlan;
-        const generated = parsedInput.source === 'js'
-            ? generateTestFromGroups(normalizedRecording.title, resolvedJsGeneration?.itGroups ?? hydratedSuitePlan?.itGroups ?? toItGroups(analyzedRecording, normalizedRecording.title), {
-                outputPath,
-                dryRun: options.dryRun,
-                conventions,
-                queryResults: resolvedJsGeneration?.queryResults ?? [],
-                helpers: hydratedSuitePlan?.helpers,
-                scenarios: hydratedSuitePlan?.scenarios,
-                renderTarget: repoRenderTarget,
-            })
-            : generateTest(analyzedRecording, { outputPath, dryRun: options.dryRun });
+        const generationHelpers = hydratedSuitePlan
+            ? stripSemanticMarkerStepsFromHelpers(hydratedSuitePlan.helpers)
+            : undefined;
+        const generationScenarios = hydratedSuitePlan && generationHelpers
+            ? stripSemanticMarkerStepsFromScenarios(hydratedSuitePlan.scenarios, generationHelpers)
+            : undefined;
+        const generationItGroups = stripSemanticMarkerStepsFromItGroups(resolvedJsGeneration?.itGroups ??
+            hydratedSuitePlan?.itGroups ??
+            toItGroups(analyzedRecording, normalizedRecording.title));
+        const generated = generateTestFromGroups(normalizedRecording.title, generationItGroups, {
+            outputPath,
+            conventions,
+            queryResults: resolvedJsGeneration?.queryResults ?? [],
+            helpers: generationHelpers,
+            scenarios: generationScenarios,
+            renderTarget: repoRenderTarget,
+        });
+        const markerCoverage = buildMarkerCoverageSummary({
+            analyzedRecording,
+            suitePlan: hydratedSuitePlan,
+        });
         if (hydratedSuitePlan?.warnings.length) {
             generated.code = [
-                ...hydratedSuitePlan.warnings.map((warning) => `// taro-boundary-warning: ${warning}`),
+                ...hydratedSuitePlan.warnings.map((warning) => `// tayo-boundary-warning: ${warning}`),
                 generated.code,
             ].join('\n');
         }
-        if (parsedInput.source === 'js') {
-            emitQuerySummary(resolvedJsGeneration?.queryResults ?? []);
-        }
-        const scoreResult = parsedInput.source === 'js'
-            ? scoreGeneratedTest(generated.code, resolvedJsGeneration?.queryResults ?? [])
-            : scoreGeneratedTest(generated.code);
+        emitQuerySummary(resolvedJsGeneration?.queryResults ?? []);
+        const scoreResult = scoreGeneratedTest(generated.code, {
+            queryResults: resolvedJsGeneration?.queryResults ?? [],
+            markerCoverage,
+        });
         const boundaryIssues = analyzeBoundaryIsolation(generated.code);
         logScore(scoreResult);
+        emitMarkerCoverageSection(scoreResult);
+        emitUnresolvedMarkerWarnings(hydratedSuitePlan);
         emitLowConfidenceBanner(scoreResult);
         emitScoreHints(scoreResult, resolvedJsGeneration?.queryResults ?? [], boundaryIssues);
-        if (options.dryRun) {
-            console.log(pc.yellow('\nDry run — test preview:\n'));
-            console.log(pc.dim('─'.repeat(60)));
-            console.log(generated.code);
-            console.log(pc.dim('─'.repeat(60)));
-            console.log(pc.dim(`\n[taro] Score: ${scoreResult.total}/100 (${scoreResult.grade})`));
-            console.log(pc.yellow(`\nWould write to: ${pc.bold(outputPath)}`));
-            return;
-        }
         try {
-            const result = await writeTestFile(generated.code, outputPath, {
-                force: options.force,
-                createDir: true,
-            });
+            const result = await writeTestFile(generated.code, outputPath, { createDir: true });
             await finalizeGeneratedOutput({
                 code: generated.code,
                 outputPath: result.filePath,
@@ -586,6 +748,7 @@ export function createGenerateCommand() {
             });
             const action = result.overwritten ? pc.yellow('Updated') : pc.green('Created');
             console.log(`${action}: ${pc.bold(result.filePath)}`);
+            enforceMarkerGateExit(scoreResult);
         }
         catch (err) {
             console.error(pc.red('Error:') + ` ${String(err)}`);