@tayo-dev/rtl 1.3.0 → 1.4.0

package/dist/cli/commands/generate.js

@@ -10,47 +10,137 @@ import { cwd } from 'node:process';
 import pc from 'picocolors';
 import { generateTest } from '../../core/generator.js';
 import { writeTestFile } from '../../core/writer.js';
-import { captureVisualState, inspectElements, buildQuery, selectMatcher, emitQry03Warning, } from '../../core/resolver.js';
+import { captureVisualState, resolveSelector, } from '../../core/resolver.js';
 import { scoreGeneratedTest } from '../../core/scorer.js';
 import { analyzeBoundaryIsolation } from '../../core/boundary-intelligence.js';
 import { verifySyntax } from '../../core/verifier.js';
-import { analyzeSingleTestFile, mergeConventions, readConventions, scanConventions, } from '../../core/scanner.js';
+import { analyzeSingleTestFile, discoverRepoRenderTargets, mergeConventions, readConventions, scanConventions, } from '../../core/scanner.js';
 import { analyzeRecording, findVisualCaptureCandidates, } from '../../core/recording-intelligence.js';
 import { analyzeMocks } from '../../core/mock-intelligence.js';
 import { generateTestFromGroups, emitQuerySummary } from '../../core/generator.js';
 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?)$/, '');
     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, mode) {
+    if (!scoreResult.markerQualityGate.failing) {
+        return;
+    }
+    process.exitCode = 1;
+    const modeLabel = mode === 'dry-run' ? '--dry-run preview' : 'write mode output';
+    console.error(pc.red(`[tayo] Exiting with code 1: QUAL-02 gate failed after ${modeLabel}.`));
+}
+function emitLowConfidenceBanner(scoreResult) {
+    if (!scoreResult.requiresReview) {
+        return;
+    }
+    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(`[tayo] Top blockers: ${scoreResult.blockers.join(' | ')}`));
+    }
 }
 function emitScoreHints(scoreResult, queryResults = [], boundaryIssues = analyzeBoundaryIsolation('')) {
     if (scoreResult.dimensions.queryQuality < 60) {
         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}`));
         }
     }
 }
@@ -60,6 +150,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)`);
     }
@@ -72,7 +168,72 @@ 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 { source, analyzedRecording, suitePlan } = params;
+    if (source !== 'js') {
+        return EMPTY_MARKER_COVERAGE;
+    }
+    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) {
@@ -93,6 +254,110 @@ function queryDescriptorToResult(descriptor) {
         line: descriptor.line,
     };
 }
+function isQueryDescriptor(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'method' in value &&
+        typeof value.method === 'string');
+}
+function getStepQueryDescriptor(step) {
+    const query = step.metadata?.query;
+    return isQueryDescriptor(query) ? query : undefined;
+}
+function groupSelectorsByStepId(selectors) {
+    const grouped = new Map();
+    for (const selector of selectors) {
+        const current = grouped.get(selector.stepId) ?? [];
+        current.push(selector);
+        grouped.set(selector.stepId, current);
+    }
+    return grouped;
+}
+function mergeSelectorResolutionWarnings(resolution, warnings) {
+    const mergedWarnings = Array.from(new Set([...resolution.warnings, ...warnings]));
+    if (mergedWarnings.length === resolution.warnings.length) {
+        return resolution;
+    }
+    return {
+        ...resolution,
+        warnings: mergedWarnings,
+    };
+}
+function applySelectorResolution(step, resolution) {
+    return {
+        ...step,
+        metadata: {
+            ...step.metadata,
+            selectorResolution: resolution,
+            ...(resolution.status === 'resolved' ? { query: resolution.query } : {}),
+        },
+    };
+}
+function rehydrateItGroups(itGroups, steps) {
+    const stepMap = new Map(steps.map((step) => [step.id, step]));
+    return itGroups.map((group) => ({
+        ...group,
+        steps: group.steps.map((step) => (step.id ? stepMap.get(step.id) ?? step : step)),
+    }));
+}
+function rehydrateSuitePlan(plan, steps) {
+    const stepMap = new Map(steps.map((step) => [step.id, step]));
+    const mapStep = (step) => (step.id ? stepMap.get(step.id) ?? step : step);
+    return {
+        ...plan,
+        itGroups: rehydrateItGroups(plan.itGroups, steps),
+        helpers: plan.helpers.map((helper) => ({
+            ...helper,
+            steps: helper.steps.map(mapStep),
+        })),
+        scenarios: plan.scenarios.map((scenario) => ({
+            ...scenario,
+            steps: scenario.steps.map(mapStep),
+        })),
+    };
+}
+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) => {
+        const key = `${queryResult.method}:${queryResult.query}:${queryResult.line ?? 'na'}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
 function getPrimarySelector(recording) {
     return recording.baseline?.selectors[0]?.selector;
 }
@@ -107,7 +372,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) {
@@ -126,71 +391,173 @@ 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) {
+    return value
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((token) => token.length >= 3);
+}
+function scoreRenderTargetCandidate(candidate, recording, mockAnalysis, suitePlan) {
+    const recordingTokens = new Set([
+        ...tokenizeSuiteHint(recording.title),
+        ...recording.steps.flatMap((step) => tokenizeSuiteHint(step.target ?? '')),
+    ]);
+    const candidateTokens = new Set([
+        ...tokenizeSuiteHint(candidate.symbol),
+        ...tokenizeSuiteHint(candidate.importPath),
+        ...tokenizeSuiteHint(candidate.sourceTestFile),
+        ...candidate.helperNames.flatMap((name) => tokenizeSuiteHint(name)),
+    ]);
+    let score = 0;
+    for (const token of candidateTokens) {
+        if (recordingTokens.has(token)) {
+            score += 3;
+        }
     }
+    if (/Module$/u.test(candidate.symbol) && suitePlan.renderBoundary.kind === 'module') {
+        score += 4;
+    }
+    if (candidate.usesWithin) {
+        score += 1;
+    }
+    if (mockAnalysis?.repeatedTargets.length) {
+        score += 1;
+    }
+    return score;
+}
+function resolveRepoRenderTarget(params) {
+    const { candidates, recording, mockAnalysis, suitePlan } = params;
+    if (candidates.length === 0) {
+        return null;
+    }
+    const ranked = candidates
+        .map((candidate) => ({
+        candidate,
+        score: scoreRenderTargetCandidate(candidate, recording, mockAnalysis, suitePlan),
+    }))
+        .filter((entry) => entry.score > 0)
+        .sort((left, right) => right.score - left.score || left.candidate.symbol.localeCompare(right.candidate.symbol));
+    return ranked[0]?.candidate ?? null;
+}
+function applyRepoRenderTarget(suitePlan, renderTarget) {
+    if (!renderTarget) {
+        return suitePlan;
+    }
+    return {
+        ...suitePlan,
+        renderBoundary: {
+            ...suitePlan.renderBoundary,
+            resolvedTarget: renderTarget.symbol,
+            confidence: suitePlan.renderBoundary.confidence === 'low' ? 'medium' : suitePlan.renderBoundary.confidence,
+        },
+        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')),
+    };
 }
 function findRecordingUrl(analyzedRecording) {
     return analyzedRecording.url ?? analyzedRecording.steps.find((step) => step.action === 'navigate')?.target;
 }
-async function resolveJsQueryResults(recording) {
+async function resolveJsGeneration(recording, itGroups) {
     const baseline = recording.baseline;
     if (!baseline) {
-        return [];
+        return {
+            itGroups,
+            queryResults: [],
+            recording,
+            warnings: [],
+        };
     }
     const queryResults = baseline.queries.map(queryDescriptorToResult);
-    if (baseline.selectors.length > 0 && recording.url) {
-        console.log(pc.dim('[taro]') +
+    const warnings = [];
+    const selectorGroups = groupSelectorsByStepId(baseline.selectors);
+    const stepMap = new Map(recording.steps
+        .filter((step) => Boolean(step.id))
+        .map((step) => [step.id, step]));
+    const updatedSteps = new Map();
+    if (selectorGroups.size > 0 && recording.url) {
+        console.log(pc.dim('[tayo]') +
             ` Resolving ${baseline.selectors.length} selector(s) via Playwright...`);
-        const selectors = baseline.selectors.map((descriptor) => descriptor.selector);
-        const elementMap = await inspectElements(recording.url, selectors);
-        for (const descriptor of baseline.selectors) {
-            const info = elementMap.get(descriptor.selector) ?? null;
-            if (!info) {
-                const fallbackResult = buildQuery({
-                    tagName: 'div',
-                    role: null,
-                    ariaLabel: null,
-                    ariaLabelledBy: null,
-                    innerText: '',
-                    value: undefined,
-                    type: undefined,
-                    placeholder: null,
-                    isPresent: false,
-                }, descriptor.selector);
-                queryResults.push({ ...fallbackResult, line: descriptor.line });
-                continue;
+    }
+    for (const [stepId, selectors] of selectorGroups) {
+        const step = updatedSteps.get(stepId) ?? stepMap.get(stepId);
+        if (!step) {
+            continue;
+        }
+        const preservedQuery = getStepQueryDescriptor(step);
+        const stepWarnings = [];
+        let chosenResolution;
+        if (preservedQuery) {
+            chosenResolution = await resolveSelector(selectors[0], {
+                url: recording.url,
+                preservedQuery,
+            });
+        }
+        else {
+            for (const selector of selectors) {
+                const resolution = await resolveSelector(selector, {
+                    url: recording.url,
+                });
+                if (resolution.status === 'resolved') {
+                    chosenResolution = resolution;
+                    break;
+                }
+                stepWarnings.push(...resolution.warnings);
+                chosenResolution ??= resolution;
             }
-            const result = buildQuery(info, descriptor.selector);
-            if (result.quality === 'fragile') {
-                emitQry03Warning(descriptor.selector);
+        }
+        if (!chosenResolution) {
+            continue;
+        }
+        const resolution = mergeSelectorResolutionWarnings(chosenResolution, stepWarnings);
+        updatedSteps.set(stepId, applySelectorResolution(step, resolution));
+        if (resolution.status === 'resolved') {
+            if (resolution.outcome !== 'preserved-query') {
+                queryResults.push(queryDescriptorToResult(resolution.query));
             }
-            const matcher = selectMatcher(info, 'assert');
-            queryResults.push({ ...result, matcher, line: descriptor.line });
+            continue;
         }
+        warnings.push(`QRY-03 [${stepId}] unresolved selector ${resolution.selector.selector}: ${resolution.reason}`);
     }
-    else if (baseline.selectors.length > 0 && !recording.url) {
-        console.warn(pc.yellow('[taro]') +
-            ' QRY-02: No @jest-environment-options URL found — cannot resolve document.querySelector selectors. Falling back to getByTestId.');
+    const resolvedSteps = recording.steps.map((step) => step.id ? updatedSteps.get(step.id) ?? step : step);
+    return {
+        itGroups: rehydrateItGroups(itGroups, resolvedSteps),
+        queryResults: dedupeQueryResults(queryResults),
+        recording: {
+            ...recording,
+            baseline: {
+                ...baseline,
+                itGroups: rehydrateItGroups(baseline.itGroups, resolvedSteps),
+            },
+            steps: resolvedSteps,
+        },
+        warnings,
+    };
+}
+function summarizeSelectorWarnings(warnings) {
+    for (const warning of warnings) {
+        console.warn(pc.yellow(`[tayo] ${warning}`));
     }
-    return queryResults;
 }
 async function maybeCaptureVisualState(params) {
     const { analyzedRecording, projectRoot, selector, url } = params;
@@ -198,7 +565,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, {
@@ -226,7 +593,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 = [];
@@ -245,12 +612,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,
@@ -269,8 +636,8 @@ async function finalizeGeneratedOutput(params) {
 export function createGenerateCommand() {
     const generate = new Command('generate');
     generate
-        .description('Generate RTL test from Recorder export')
-        .argument('<file>', 'Path to the recorder export file')
+        .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)
@@ -295,12 +662,14 @@ export function createGenerateCommand() {
         }
         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...');
+                console.log(pc.dim('[tayo]') + ' Scanning project conventions...');
                 conventions = await scanConventions(projectRoot);
             }
+            repoRenderTargets = await discoverRepoRenderTargets(projectRoot);
         }
         console.log(pc.green('Parsed:') +
             ` ${pc.bold(normalizedRecording.title)} — ${normalizedRecording.steps.length} steps` +
@@ -308,6 +677,9 @@ export function createGenerateCommand() {
                 ? `, ${normalizedRecording.baseline?.itGroups.length ?? 0} test group(s)`
                 : ''));
         const analyzedRecording = analyzeRecording(normalizedRecording);
+        const markerAwareRecording = parsedInput.source === 'js'
+            ? mergeAnalyzedStepState(normalizedRecording, analyzedRecording)
+            : normalizedRecording;
         summarizeCleanup(analyzedRecording);
         const visualState = await maybeCaptureVisualState({
             analyzedRecording,
@@ -318,49 +690,94 @@ export function createGenerateCommand() {
         summarizeVisualState(visualState);
         const mockAnalysis = await maybeAnalyzeMocks(projectRoot);
         summarizeMockAnalysis(mockAnalysis);
-        const queryResults = parsedInput.source === 'js' ? await resolveJsQueryResults(normalizedRecording) : [];
         const outputPath = options.output ?? deriveOutputPath(filePath);
-        const jsSuitePlan = parsedInput.source === 'js'
+        const rawJsSuitePlan = parsedInput.source === 'js'
             ? planJsSuite({
-                recording: normalizedRecording,
+                recording: markerAwareRecording,
                 analyzedRecording,
                 mockAnalysis,
                 fallbackTitle: normalizedRecording.title,
             })
             : null;
+        const repoRenderTarget = parsedInput.source === 'js' && rawJsSuitePlan
+            ? resolveRepoRenderTarget({
+                candidates: repoRenderTargets,
+                recording: normalizedRecording,
+                mockAnalysis,
+                suitePlan: rawJsSuitePlan,
+            })
+            : null;
+        const jsSuitePlan = rawJsSuitePlan
+            ? applyRepoRenderTarget(rawJsSuitePlan, repoRenderTarget)
+            : null;
         if (jsSuitePlan) {
             summarizeBoundaryWarnings(jsSuitePlan.warnings);
         }
+        const resolvedJsGeneration = parsedInput.source === 'js'
+            ? await resolveJsGeneration(markerAwareRecording, jsSuitePlan?.itGroups ?? toItGroups(analyzedRecording, normalizedRecording.title))
+            : null;
+        if (resolvedJsGeneration) {
+            summarizeSelectorWarnings(resolvedJsGeneration.warnings);
+        }
+        const hydratedSuitePlan = parsedInput.source === 'js' && jsSuitePlan
+            ? rehydrateSuitePlan(jsSuitePlan, resolvedJsGeneration?.recording.steps ?? markerAwareRecording.steps)
+            : jsSuitePlan;
+        const generationHelpers = hydratedSuitePlan
+            ? stripSemanticMarkerStepsFromHelpers(hydratedSuitePlan.helpers)
+            : undefined;
+        const generationScenarios = hydratedSuitePlan && generationHelpers
+            ? stripSemanticMarkerStepsFromScenarios(hydratedSuitePlan.scenarios, generationHelpers)
+            : undefined;
+        const generationItGroups = parsedInput.source === 'js'
+            ? stripSemanticMarkerStepsFromItGroups(resolvedJsGeneration?.itGroups ??
+                hydratedSuitePlan?.itGroups ??
+                toItGroups(analyzedRecording, normalizedRecording.title))
+            : toItGroups(analyzedRecording, normalizedRecording.title);
         const generated = parsedInput.source === 'js'
-            ? generateTestFromGroups(normalizedRecording.title, jsSuitePlan?.itGroups ?? toItGroups(analyzedRecording, normalizedRecording.title), {
+            ? generateTestFromGroups(normalizedRecording.title, generationItGroups, {
                 outputPath,
                 dryRun: options.dryRun,
                 conventions,
-                queryResults,
+                queryResults: resolvedJsGeneration?.queryResults ?? [],
+                helpers: generationHelpers,
+                scenarios: generationScenarios,
+                renderTarget: repoRenderTarget,
             })
             : generateTest(analyzedRecording, { outputPath, dryRun: options.dryRun });
-        if (jsSuitePlan?.warnings.length) {
+        const markerCoverage = buildMarkerCoverageSummary({
+            source: parsedInput.source,
+            analyzedRecording,
+            suitePlan: hydratedSuitePlan,
+        });
+        if (hydratedSuitePlan?.warnings.length) {
             generated.code = [
-                ...jsSuitePlan.warnings.map((warning) => `// taro-boundary-warning: ${warning}`),
+                ...hydratedSuitePlan.warnings.map((warning) => `// tayo-boundary-warning: ${warning}`),
                 generated.code,
             ].join('\n');
         }
         if (parsedInput.source === 'js') {
-            emitQuerySummary(queryResults);
+            emitQuerySummary(resolvedJsGeneration?.queryResults ?? []);
         }
         const scoreResult = parsedInput.source === 'js'
-            ? scoreGeneratedTest(generated.code, queryResults)
-            : scoreGeneratedTest(generated.code);
+            ? scoreGeneratedTest(generated.code, {
+                queryResults: resolvedJsGeneration?.queryResults ?? [],
+                markerCoverage,
+            })
+            : scoreGeneratedTest(generated.code, { markerCoverage });
         const boundaryIssues = analyzeBoundaryIsolation(generated.code);
         logScore(scoreResult);
-        emitScoreHints(scoreResult, queryResults, boundaryIssues);
+        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.dim(`\n[tayo] Score: ${scoreResult.total}/100 (${scoreResult.grade})`));
             console.log(pc.yellow(`\nWould write to: ${pc.bold(outputPath)}`));
+            enforceMarkerGateExit(scoreResult, 'dry-run');
             return;
         }
         try {
@@ -377,6 +794,7 @@ export function createGenerateCommand() {
             });
             const action = result.overwritten ? pc.yellow('Updated') : pc.green('Created');
             console.log(`${action}: ${pc.bold(result.filePath)}`);
+            enforceMarkerGateExit(scoreResult, 'write');
         }
         catch (err) {
             console.error(pc.red('Error:') + ` ${String(err)}`);