@ivorycanvas/qamap 0.3.2 → 0.3.4

package/dist/e2e.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import YAML from "yaml";
 import { buildDomainLanguageSummary } from "./domain-language.js";
 import { defaultDomainManifestPath, loadDomainManifest, matchDomains } from "./domains.js";
+import { analyzeFixtureSource, insightCoversEndpoint } from "./fixture-insight.js";
 import { collectProjectFiles } from "./fs.js";
 import { buildReverseImportIndex, expandChangedFilesWithImporters, findImportingSurfaces } from "./import-graph.js";
 import { loadCoreFlowManifest, matchCoreFlows } from "./flows.js";
@@ -10,6 +11,19 @@ import { loadVerificationManifest, matchVerificationManifest } from "./manifest.
 import { collectTestSuiteInventory, evaluateFlowCoverageEvidence, summarizeTestSuiteInventory, } from "./test-evidence.js";
 import { collectAddedDiffText, generateTestPlan } from "./test-plan.js";
 import { TOOL_NAME, VERSION } from "./version.js";
+// Human reports render readiness as a stage on a fixed journey instead of a
+// verdict, so a first run reads as "you are at the start", not "you failed".
+// JSON/agent output keeps the raw level values as the stable contract.
+const draftReadinessStages = {
+    blocked: { position: 1, label: "setup needed" },
+    "needs-work": { position: 2, label: "draft in progress" },
+    "near-runnable": { position: 3, label: "almost runnable" },
+    ready: { position: 4, label: "ready to run" },
+};
+export function formatDraftReadinessStage(summary) {
+    const stage = draftReadinessStages[summary.level];
+    return `${stage.label} (${stage.position} of 4) — readiness ${summary.score}/100`;
+}
 const maxFilesPerFlow = 8;
 const workspacePackageSearchLimit = 200;
 const workspacePackageIgnoredDirectories = new Set([
@@ -30,7 +44,10 @@ export async function generateE2ePlan(rootInput, options = {}) {
     const root = path.resolve(rootInput);
     const testPlan = await generateTestPlan(root, options);
     const project = await detectProjectProfile(root, testPlan.workspaceRoot);
-    const recommendedRunner = options.runner ? overrideRunner(project, options.runner) : recommendRunner(project);
+    const changedPaths = testPlan.changedFiles.map((file) => file.path);
+    const recommendedRunner = options.runner
+        ? overrideRunner(project, options.runner)
+        : recommendRunnerForChange(project, changedPaths);
     const executionProfile = await buildExecutionProfile(root, testPlan.workspaceRoot, project, recommendedRunner.name);
     const testSuiteInventory = await collectTestSuiteInventory(root);
     const coreFlowRoot = testPlan.workspaceRoot ?? root;
@@ -114,6 +131,12 @@ export async function generateE2ePlan(rootInput, options = {}) {
 export async function generateE2eDraft(rootInput, options = {}) {
     const root = path.resolve(rootInput);
     const plan = await generateE2ePlan(root, options);
+    const addedDiffText = await collectAddedDiffText(root, {
+        base: plan.base,
+        head: plan.head,
+        workspaceRoot: plan.workspaceRoot,
+        includeWorkingTree: options.includeWorkingTree,
+    });
     const runner = plan.recommendedRunner.name;
     const outputDirectory = path.resolve(root, options.output ?? defaultDraftOutputDirectory(runner));
     const draftLimit = options.maxDrafts && options.maxDrafts > 0 ? Math.floor(options.maxDrafts) : undefined;
@@ -130,7 +153,7 @@ export async function generateE2eDraft(rootInput, options = {}) {
         const promotionGuidance = buildDraftPromotionGuidance(flow);
         const fileAlreadyExists = await exists(filePath);
         const shouldSkip = fileAlreadyExists && !options.force && !dryRun;
-        const content = shouldSkip ? ((await readTextIfExists(filePath)) ?? "") : draftContentForFlow(plan, flow, runner);
+        const content = shouldSkip ? ((await readTextIfExists(filePath)) ?? "") : draftContentForFlow(plan, flow, runner, addedDiffText);
         const todoCount = countTodos(content);
         const selfCheck = evaluateDraftSelfCheck(plan, flow, runner, content, todoCount);
         const actionItems = buildDraftActionItems(plan, flow, runner, validationSummary, promotionGuidance, selfCheck);
@@ -453,6 +476,7 @@ function buildE2eValidationMatrix(flows, coreFlows) {
 }
 function buildE2eBootstrapPlan(input) {
     const steps = [];
+    const verificationOnly = input.flows.length > 0 && input.flows.every(isVerificationOnlyFlow);
     const runnerGap = input.missingTestability.find((gap) => /No \.maestro|No Playwright config/i.test(gap));
     const draftCommand = `qamap e2e draft . --base ${input.base} --head ${input.head}`;
     const planHistoryCommand = `qamap e2e plan . --base ${input.base} --head ${input.head} --record-history`;
@@ -465,7 +489,10 @@ function buildE2eBootstrapPlan(input) {
             ? `${concreteTargets.length} changed workspace target${concreteTargets.length === 1 ? "" : "s"} have clearer app or service signals than the workspace root.`
             : "Changed files map to workspace packages, but their app surface still needs a package-scoped review.", "Run the suggested package-scoped plan commands, then generate drafts from the package whose changed flow is user-facing.", input.workspaceTargets.map((target) => target.suggestedCommand).slice(0, 4), input.workspaceTargets.flatMap((target) => target.changedFiles).slice(0, maxFilesPerFlow)));
     }
-    if (input.recommendedRunner.name === "manual") {
+    if (verificationOnly) {
+        steps.push(bootstrapStep("runner", "ready", "Use repository validation for this verification-only change", "The diff maps to configuration, documentation, generated output, or existing test evidence rather than a new product journey.", "Run the nearest repository validation command and attach the result as PR evidence; no UI runner setup is required by this diff alone.", input.suggestedCommands.slice(0, 4), input.flows.flatMap((flow) => flow.files).slice(0, maxFilesPerFlow)));
+    }
+    else if (input.recommendedRunner.name === "manual") {
         steps.push(bootstrapStep("runner", "required", manualBootstrapTitle(input.projectType), manualBootstrapReason(input.projectType), manualBootstrapAction(input.projectType), [], []));
     }
     else if (runnerGap) {
@@ -481,27 +508,30 @@ function buildE2eBootstrapPlan(input) {
     else {
         steps.push(bootstrapStep("runner", "ready", `${formatRunnerName(input.recommendedRunner.name)} setup signal detected`, "QAMap found enough runner setup evidence to generate runnable drafts.", "Keep runner setup documented and linked from PR validation notes.", [], []));
     }
-    if (input.recommendedRunner.name !== "manual" && executionProfileBlockers.length > 0) {
+    if (!verificationOnly && input.recommendedRunner.name !== "manual" && executionProfileBlockers.length > 0) {
         steps.push(bootstrapStep("runner", "required", "Complete the E2E execution profile", executionProfileBlockers.slice(0, 3).join(" "), "Document or configure the missing command, URL, app id, or runner file before treating generated drafts as runnable regression coverage.", uniqueStrings([input.executionProfile.startCommand, input.executionProfile.testCommand].filter(Boolean)), input.executionProfile.configFiles));
     }
-    if (!input.testSuite.hasTestSuite) {
+    if (verificationOnly) {
+        steps.push(bootstrapStep("draft", "ready", "No new E2E draft required for this change", "The changed files are verification inputs or existing evidence, so generating another product-journey test would duplicate or invent coverage.", "Run the changed evidence or nearest build, lint, typecheck, documentation, or artifact validation command and record its result.", input.suggestedCommands.slice(0, 4), input.flows.flatMap((flow) => flow.files).slice(0, maxFilesPerFlow)));
+    }
+    else if (!input.testSuite.hasTestSuite) {
         steps.push(bootstrapStep("draft", "required", "Create the first changed-flow E2E draft", "No existing test files were detected, so this branch needs a concrete first draft before QAMap can compare coverage evidence.", "Generate the first draft, replace TODO selectors and setup values, then decide which paths should become required regression coverage.", [draftCommand], input.flows.flatMap((flow) => flow.files).slice(0, maxFilesPerFlow)));
     }
     else {
         steps.push(bootstrapStep("draft", "ready", "Existing test suite detected", `${input.testSuite.testFileCount} test file${input.testSuite.testFileCount === 1 ? "" : "s"} can be used as coverage evidence.`, "Use the validation matrix to expand existing tests or generated drafts only where evidence is weak.", [], []));
     }
-    if (!input.domainManifestPath && input.domainLanguage.terms.length > 0) {
+    if (!verificationOnly && !input.domainManifestPath && input.domainLanguage.terms.length > 0) {
         steps.push(bootstrapStep("domain-language", "recommended", "Promote repeated product words into a domain manifest", `QAMap inferred ${input.domainLanguage.terms.length} domain term${input.domainLanguage.terms.length === 1 ? "" : "s"} from changed files, but no shared domain manifest was found.`, "Generate a suggested domain manifest from this branch, review names and routes with the team, then commit only the terms that match team language.", [domainsSuggestCommand, `${domainsSuggestCommand} --write .qamap/domains.yml`], input.domainLanguage.terms.flatMap((term) => term.files).slice(0, maxFilesPerFlow)));
     }
-    else if (input.domainManifestPath || input.domains.length > 0) {
+    else if (!verificationOnly && (input.domainManifestPath || input.domains.length > 0)) {
         steps.push(bootstrapStep("domain-language", "ready", "Domain language has shared policy evidence", input.domainManifestPath
             ? `Domain manifest found at ${input.domainManifestPath}.`
             : "Matched domain definitions were found.", "Keep committed domain language aligned with the names used in generated E2E drafts.", [], []));
     }
-    if (!input.coreFlowManifestPath) {
+    if (!verificationOnly && !input.coreFlowManifestPath) {
         steps.push(bootstrapStep("core-flow", input.flows.length > 0 ? "recommended" : "required", "Capture the first durable core flows", "No .qamap/flows.yml manifest was found, so QAMap can infer changed-flow candidates but cannot distinguish team-critical journeys yet.", "Generate suggested flow entries from this branch, keep only the journeys humans agree are durable, then commit them as team policy.", [flowsSuggestCommand, `${flowsSuggestCommand} --write .qamap/flows.yml`], input.flows.flatMap((flow) => flow.files).slice(0, maxFilesPerFlow)));
     }
-    else {
+    else if (!verificationOnly) {
         steps.push(bootstrapStep("core-flow", input.coreFlows.length > 0 ? "ready" : "recommended", input.coreFlows.length > 0 ? "Core flow manifest matched this change" : "Review core flow manifest coverage", input.coreFlows.length > 0
             ? `${input.coreFlows.length} declared core flow${input.coreFlows.length === 1 ? "" : "s"} matched the changed files.`
             : `Core flow manifest found at ${input.coreFlowManifestPath}, but this change did not match a declared flow.`, input.coreFlows.length > 0
@@ -521,24 +551,30 @@ function buildE2eBootstrapPlan(input) {
                 : `${partialFixtureRows.length} API-dependent flows have only partial fixture evidence.`, "Cover success plus one empty, unauthorized, timeout, rejected, or server-error response before requiring the generated draft.", [], uniqueStrings([...missingFixtureRows, ...partialFixtureRows].flatMap((row) => row.files)).slice(0, maxFilesPerFlow)));
     }
     const nonRunnerTestabilityGaps = input.missingTestability.filter((gap) => !/No \.maestro|No Playwright config/i.test(gap));
-    if (nonRunnerTestabilityGaps.length > 0) {
+    if (!verificationOnly && nonRunnerTestabilityGaps.length > 0) {
         steps.push(bootstrapStep("testability", "required", "Add stable selectors for changed user actions", `${nonRunnerTestabilityGaps.length} selector or interaction gap${nonRunnerTestabilityGaps.length === 1 ? "" : "s"} were detected.`, "Add stable test ids, accessibility labels, roles, or durable visible copy for the controls the draft must tap, type into, or assert.", [], input.flows.flatMap((flow) => flow.files).slice(0, maxFilesPerFlow)));
     }
-    else if (input.flows.some((flow) => flow.selectors.length > 0 || flow.entrypoints.length > 0)) {
+    else if (!verificationOnly && input.flows.some((flow) => flow.selectors.length > 0 || flow.entrypoints.length > 0)) {
         steps.push(bootstrapStep("testability", "ready", "Entrypoint or selector evidence detected", "Generated drafts can reuse detected routes, screens, selectors, labels, or visible copy.", "Review the generated locators and replace weak starter assertions with domain-specific checks before promoting the draft.", [], input.flows.flatMap((flow) => flow.selectors.map((selector) => selector.file)).slice(0, maxFilesPerFlow)));
     }
     if (input.validationMatrix.summary.missing > 0) {
         steps.push(bootstrapStep("validation", "required", "Close missing validation matrix rows", input.validationMatrix.summary.missing === 1
             ? "1 validation row is missing evidence."
-            : `${input.validationMatrix.summary.missing} validation rows are missing evidence.`, "Resolve missing coverage, fixture, setup, and testability rows before calling generated E2E coverage sufficient.", [], input.validationMatrix.rows.filter((row) => row.status === "missing").flatMap((row) => row.files).slice(0, maxFilesPerFlow)));
+            : `${input.validationMatrix.summary.missing} validation rows are missing evidence.`, verificationOnly
+            ? "Run or record the missing repository validation checks before treating this change as verified."
+            : "Resolve missing coverage, fixture, setup, and testability rows before calling generated E2E coverage sufficient.", [], input.validationMatrix.rows.filter((row) => row.status === "missing").flatMap((row) => row.files).slice(0, maxFilesPerFlow)));
     }
     else if (input.validationMatrix.summary.partial > 0) {
         steps.push(bootstrapStep("validation", "recommended", "Strengthen partial validation evidence", input.validationMatrix.summary.partial === 1
             ? "1 validation row is only partial."
-            : `${input.validationMatrix.summary.partial} validation rows are only partial.`, "Expand the generated draft or existing tests until the critical rows have concrete evidence.", [], input.validationMatrix.rows.filter((row) => row.status === "partial").flatMap((row) => row.files).slice(0, maxFilesPerFlow)));
+            : `${input.validationMatrix.summary.partial} validation rows are only partial.`, verificationOnly
+            ? "Run or record the partial repository checks until each critical row has concrete evidence."
+            : "Expand the generated draft or existing tests until the critical rows have concrete evidence.", [], input.validationMatrix.rows.filter((row) => row.status === "partial").flatMap((row) => row.files).slice(0, maxFilesPerFlow)));
     }
     else if (input.validationMatrix.rows.length > 0) {
-        steps.push(bootstrapStep("validation", "ready", "Validation matrix is ready", "All validation matrix rows currently have ready evidence.", "Keep the matrix linked in PR evidence when the generated draft is promoted.", [], []));
+        steps.push(bootstrapStep("validation", "ready", "Validation matrix is ready", "All validation matrix rows currently have ready evidence.", verificationOnly
+            ? "Keep the completed repository checks linked in PR evidence."
+            : "Keep the matrix linked in PR evidence when the generated draft is promoted.", [], []));
     }
     steps.push(bootstrapStep("history", "recommended", "Record local plan history while iterating", "Local run history lets the team compare how domain language, core flows, fixtures, and validation gaps evolve without spending more agent tokens.", "Run the plan with --record-history after important draft or manifest changes.", [planHistoryCommand], []));
     if (input.suggestedCommands.length === 0) {
@@ -551,7 +587,7 @@ function buildE2eBootstrapPlan(input) {
         ready: sortedSteps.filter((step) => step.status === "ready").length,
     };
     return {
-        summary: bootstrapSummary(counts, sortedSteps),
+        summary: bootstrapSummary(counts, sortedSteps, verificationOnly),
         steps: sortedSteps,
         counts,
     };
@@ -655,9 +691,12 @@ function bootstrapCategoryRank(category) {
     ];
     return order.indexOf(category);
 }
-function bootstrapSummary(counts, steps) {
+function bootstrapSummary(counts, steps, verificationOnly = false) {
     const firstRequired = steps.find((step) => step.status === "required");
     if (firstRequired) {
+        if (verificationOnly) {
+            return `${counts.required} required verification step${counts.required === 1 ? "" : "s"} must be resolved before this change has repeatable PR evidence. Start with: ${firstRequired.title}.`;
+        }
         return `${counts.required} required bootstrap step${counts.required === 1 ? "" : "s"} must be resolved before generated E2E drafts should be treated as regression coverage. Start with: ${firstRequired.title}.`;
     }
     const firstRecommended = steps.find((step) => step.status === "recommended");
@@ -916,6 +955,7 @@ function buildDraftPromotionGuidance(flow) {
 }
 function buildDraftActionItems(plan, flow, runner, validationSummary, promotionGuidance, selfCheck) {
     const items = [];
+    const verificationOnly = isVerificationOnlyFlow(flow);
     const runnerGap = runnerSetupGap(plan, runner);
     if (runnerGap) {
         const setupCommand = plan.runnerSetup.setupCommand ? ` Run \`${plan.runnerSetup.setupCommand}\` after accepting this runner setup.` : "";
@@ -925,7 +965,7 @@ function buildDraftActionItems(plan, flow, runner, validationSummary, promotionG
         items.push(draftActionItem("runner", "required", `Configure ${formatRunnerName(runner)} execution`, setupDetail));
     }
     const executionBlockers = remainingExecutionProfileBlockers(plan.executionProfile.blockers, runnerGap);
-    if (runner !== "manual" && executionBlockers.length > 0) {
+    if (!verificationOnly && runner !== "manual" && executionBlockers.length > 0) {
         items.push(draftActionItem("runner", "required", "Complete execution profile", executionBlockers.slice(0, 3).join(" ")));
     }
     const route = primaryRouteEntrypoint(flow);
@@ -936,34 +976,42 @@ function buildDraftActionItems(plan, flow, runner, validationSummary, promotionG
             items.push(draftActionItem("fixture", "required", "Replace dynamic route parameters", `Provide real fixture values for ${unresolvedParams.map((param) => param.name).join(", ")} before running ${route.value}.`));
         }
     }
+    // Endpoints ride in the title because the agent format keeps only titles.
+    const fixtureEndpointSuffix = flow.fixtureReadiness.apiEndpoints.length > 0
+        ? ` for ${formatEndpointSummary(flow.fixtureReadiness.apiEndpoints)}`
+        : "";
     if (flow.fixtureReadiness.status === "missing") {
-        items.push(draftActionItem("fixture", "required", "Add deterministic fixture or mock data", flow.fixtureReadiness.nextActions[0] ?? flow.fixtureReadiness.reason));
+        items.push(draftActionItem("fixture", "required", `Add deterministic fixture or mock data${fixtureEndpointSuffix}`, flow.fixtureReadiness.nextActions[0] ?? flow.fixtureReadiness.reason));
     }
     else if (flow.fixtureReadiness.status === "partial") {
-        items.push(draftActionItem("fixture", "recommended", "Confirm fixture coverage", flow.fixtureReadiness.nextActions[0] ?? flow.fixtureReadiness.reason));
+        items.push(draftActionItem("fixture", "recommended", `Confirm fixture coverage${fixtureEndpointSuffix}`, flow.fixtureReadiness.nextActions[0] ?? flow.fixtureReadiness.reason));
     }
-    if (flow.missingTestability.length > 0) {
+    if (!verificationOnly && flow.missingTestability.length > 0) {
         items.push(draftActionItem("selector", "required", "Replace weak or missing selectors", flow.missingTestability[0]));
     }
-    else if (flow.selectors.length === 0 && runner !== "manual") {
+    else if (!verificationOnly && flow.selectors.length === 0 && runner !== "manual") {
         items.push(draftActionItem("selector", "recommended", "Confirm stable selectors", "No stable selector hints were inferred, so review the generated locators before making this draft required."));
     }
-    if (flow.steps.length > 0 && draftNeedsAssertionWork(selfCheck)) {
+    if (!verificationOnly && flow.steps.length > 0 && draftNeedsAssertionWork(selfCheck)) {
         items.push(draftActionItem("assertion", "required", "Replace starter smoke assertions with domain assertions", `Preserve the success signal "${flow.languageBrief.successSignal}" while replacing weak fallback interactions and generic expects.`));
     }
-    if (selfCheck?.status === "fail") {
+    if (!verificationOnly && selfCheck?.status === "fail") {
         items.push(draftActionItem("validation", "required", "Resolve generated draft self-check", selfCheck.blockers[0] ?? selfCheck.summary));
     }
-    else if (selfCheck?.status === "warning") {
+    else if (!verificationOnly && selfCheck?.status === "warning") {
         items.push(draftActionItem("validation", "recommended", "Review generated draft self-check", selfCheck.summary));
     }
     if (validationSummary.blockingGapCount > 0) {
-        items.push(draftActionItem("validation", "required", "Resolve missing validation evidence", `${validationSummary.blockingGapCount} blocking validation gap${validationSummary.blockingGapCount === 1 ? "" : "s"} must be closed before using this draft as PR evidence.`));
+        items.push(draftActionItem("validation", "required", "Resolve missing validation evidence", verificationOnly
+            ? `${validationSummary.blockingGapCount} blocking validation gap${validationSummary.blockingGapCount === 1 ? "" : "s"} must be closed before treating this change as verified PR evidence.`
+            : `${validationSummary.blockingGapCount} blocking validation gap${validationSummary.blockingGapCount === 1 ? "" : "s"} must be closed before using this draft as PR evidence.`));
     }
     else if (validationSummary.gapCount > 0) {
-        items.push(draftActionItem("validation", "recommended", "Close partial validation evidence", `${validationSummary.gapCount} validation gap${validationSummary.gapCount === 1 ? "" : "s"} remain before this draft is stable regression coverage.`));
+        items.push(draftActionItem("validation", "recommended", "Close partial validation evidence", verificationOnly
+            ? `${validationSummary.gapCount} validation gap${validationSummary.gapCount === 1 ? "" : "s"} remain before this change has stable verification evidence.`
+            : `${validationSummary.gapCount} validation gap${validationSummary.gapCount === 1 ? "" : "s"} remain before this draft is stable regression coverage.`));
     }
-    if (promotionGuidance.status !== "commit-candidate") {
+    if (!verificationOnly && promotionGuidance.status !== "commit-candidate") {
         items.push(draftActionItem("manifest", "recommended", "Promote durable product language", promotionGuidance.action));
     }
     return uniqueDraftActionItems(items).slice(0, 8);
@@ -1171,8 +1219,8 @@ function draftReadinessRecommendation(level, blockers) {
             : "Close required action items before treating the drafts as regression evidence.";
     }
     return blocker
-        ? `Do not treat these drafts as runnable yet. Start with: ${withTerminalPeriod(blocker)}`
-        : "Do not treat these drafts as runnable until required setup and validation gaps are closed.";
+        ? `Keep these drafts review-only for now and start with: ${withTerminalPeriod(blocker)}`
+        : "Keep these drafts review-only until the required setup and validation gaps are closed.";
 }
 function withTerminalPeriod(value) {
     return /[.!?)]$/.test(value.trim()) ? value.trim() : `${value.trim()}.`;
@@ -1354,6 +1402,10 @@ function inferFlowSuccessSignal(flow) {
     if (/\bconfiguration verification\b/i.test(flow.title)) {
         return "the affected build or runtime variant starts cleanly and handles fallback values";
     }
+    const visibleOutcome = flow.selectors.find((selector) => selector.kind === "visible-text" && isVisibleSuccessOutcome(selector.value));
+    if (visibleOutcome) {
+        return `visible text "${visibleOutcome.value}" appears`;
+    }
     const verificationStep = flow.steps.find((step) => isAssertionStep(step));
     if (verificationStep) {
         return stripTerminalPunctuation(verificationStep);
@@ -1364,32 +1416,36 @@ function inferFlowSuccessSignal(flow) {
     }
     return "the changed journey reaches a visible, stable success state";
 }
+function isVisibleSuccessOutcome(value) {
+    return /\b(?:confirmed|saved|refreshed|succeeded|success|completed|created|updated|deleted|sent|approved|accepted)\b/i.test(value) ||
+        /(?:완료|성공|저장(?:됨|됐|되)|등록(?:됨|됐|되)|제출(?:됨|됐|되)|승인(?:됨|됐|되))/.test(value);
+}
 function inferFlowReviewQuestion(flow, successSignal) {
     if (isApiContractFocusedFlow(flow)) {
-        return `Can a reviewer confirm that the changed endpoint, handler, or service contract is exercised and that "${successSignal}" is asserted?`;
+        return `Can a reviewer confirm that the changed endpoint, handler, or service contract is exercised and this outcome is verified: ${successSignal}?`;
     }
     if (isDesignTokenFocusedFlow(flow)) {
-        return `Can a reviewer confirm that the changed token artifact is regenerated, consumed, and that "${successSignal}" is asserted?`;
+        return `Can a reviewer confirm that the changed token artifact is regenerated, consumed, and this outcome is verified: ${successSignal}?`;
     }
     if (isCatalogFocusedFlow(flow)) {
-        return `Can a reviewer confirm that the changed catalog artifact is regenerated, consumed, and that "${successSignal}" is asserted?`;
+        return `Can a reviewer confirm that the changed catalog artifact is regenerated, consumed, and this outcome is verified: ${successSignal}?`;
     }
     if (isTestEvidenceFocusedFlow(flow)) {
-        return `Can a reviewer confirm that the changed tests are run and that "${successSignal}" is documented as PR evidence?`;
+        return `Can a reviewer confirm that the changed tests are run and this outcome is documented as PR evidence: ${successSignal}?`;
     }
     if (isDocumentationFocusedFlow(flow)) {
-        return `Can a reviewer confirm that docs validation ran and that "${successSignal}" is true?`;
+        return `Can a reviewer confirm that docs validation ran and this outcome is true: ${successSignal}?`;
     }
     if (isGeneratedArtifactFocusedFlow(flow)) {
-        return `Can a reviewer confirm that the artifact was regenerated and that "${successSignal}" is true?`;
+        return `Can a reviewer confirm that the artifact was regenerated and this outcome is true: ${successSignal}?`;
     }
     if (isCliCommandFocusedFlow(flow)) {
-        return `Can a reviewer confirm that the changed command path is run and that "${successSignal}" is asserted?`;
+        return `Can a reviewer confirm that the changed command path is run and this outcome is verified: ${successSignal}?`;
     }
     if (/\bconfiguration verification\b/i.test(flow.title)) {
-        return `Can a reviewer confirm that the affected build, startup, or release variant is exercised and that "${successSignal}" is asserted?`;
+        return `Can a reviewer confirm that the affected build, startup, or release variant is exercised and this outcome is verified: ${successSignal}?`;
     }
-    return `Can a reviewer confirm that ${flow.title} still works from this entrypoint and that "${successSignal}" is asserted?`;
+    return `Can a reviewer confirm that ${flow.title} still works from this entrypoint and this outcome is verified: ${successSignal}?`;
 }
 function isApiContractFocusedFlow(flow) {
     if (isEvidenceVerificationFocusedFlow(flow)) {
@@ -1786,7 +1842,7 @@ export function formatMarkdownE2eDraft(result) {
     lines.push("");
     lines.push("## Draft Readiness Summary");
     lines.push("");
-    lines.push(`Score: ${result.readinessSummary.score}/100 (${result.readinessSummary.level}) - ${escapeMarkdownInline(result.readinessSummary.recommendation)}`);
+    lines.push(`Stage: ${formatDraftReadinessStage(result.readinessSummary)}. ${escapeMarkdownInline(result.readinessSummary.recommendation)}`);
     lines.push(`Summary: ${result.actionSummary.required} required action${result.actionSummary.required === 1 ? "" : "s"}, ${result.actionSummary.recommended} recommended action${result.actionSummary.recommended === 1 ? "" : "s"}.`);
     lines.push(`- Runnable candidates: ${result.readinessSummary.runnableCandidates}`);
     lines.push(`- Near-runnable files: ${result.readinessSummary.nearRunnable}`);
@@ -1900,7 +1956,7 @@ export function formatMarkdownE2eSetup(result) {
             lines.push(`- Output directory: \`${escapeMarkdownInline(result.draftOutputDirectory)}\``);
         }
         if (result.draftReadinessSummary) {
-            lines.push(`- Readiness: ${result.draftReadinessSummary.level} (${result.draftReadinessSummary.score}/100)`);
+            lines.push(`- Stage: ${formatDraftReadinessStage(result.draftReadinessSummary)}`);
         }
         for (const file of result.draftFiles) {
             const details = [
@@ -2215,6 +2271,21 @@ function recommendRunner(project) {
         reason: "No clear app platform was detected, so start with a manual smoke checklist before choosing a runnable E2E framework.",
     };
 }
+function recommendRunnerForChange(project, changedFiles) {
+    if (isConfigurationOnlyChange(changedFiles)) {
+        return {
+            name: "manual",
+            reason: "Use repository build and configuration validation because this diff changes configuration only; a browser or device journey would invent product coverage.",
+        };
+    }
+    if (isDocumentationOnlyChange(changedFiles) || isGeneratedOutputOnlyChange(changedFiles)) {
+        return {
+            name: "manual",
+            reason: "Use repository documentation or artifact validation because this diff does not change a runtime product surface.",
+        };
+    }
+    return recommendRunner(project);
+}
 function overrideRunner(project, runner) {
     if (runner === "maestro") {
         return {
@@ -3043,7 +3114,13 @@ function buildFlowCandidates(files, runner, projectType, domainLanguage, importI
     const behaviorFiles = files.filter((file) => !isTestLikeFile(file));
     const candidateFiles = behaviorFiles.length > 0 ? behaviorFiles : files;
     const impactSurfaceFiles = importImpacts.map((impact) => impact.surface).filter((surface) => !candidateFiles.includes(surface));
-    const uiFiles = uniqueStrings([...candidateFiles.filter(isUserFacingFile), ...impactSurfaceFiles]);
+    // Backend route modules often live under `routes/`, which is also a common
+    // frontend surface directory. Once the repository is classified as an API
+    // service, keep those files in contract analysis instead of inventing a UI
+    // journey that the project cannot run.
+    const uiFiles = projectType === "api-service"
+        ? []
+        : uniqueStrings([...impactSurfaceFiles, ...candidateFiles.filter(isUserFacingFile)]);
     const apiFiles = candidateFiles.filter(isApiLikeFile);
     const apiServiceSourceFiles = projectType === "api-service"
         ? candidateFiles.filter((file) => !apiFiles.includes(file) && !isConfigLikeFile(file) && isServiceSourceFile(file))
@@ -3061,7 +3138,8 @@ function buildFlowCandidates(files, runner, projectType, domainLanguage, importI
     const domainFiles = candidateFiles.filter(isDomainOwnedFile);
     const candidates = [];
     if (uiFiles.length > 0) {
-        const subject = summarizeFlowSubject(uiFiles, "Changed", domainLanguage);
+        const subjectFiles = impactSurfaceFiles.length > 0 ? impactSurfaceFiles : uiFiles;
+        const subject = summarizeFlowSubject(subjectFiles, "Changed", domainLanguage);
         const impactReason = importImpacts.length > 0
             ? ` Changed shared files reach these surfaces through imports: ${importImpacts.slice(0, 3).map(describeImportChain).join("; ")}.`
             : "";
@@ -3180,7 +3258,9 @@ function buildFlowCandidates(files, runner, projectType, domainLanguage, importI
     if (configFiles.length > 0) {
         const subject = isReleaseMetadataOnlyChange(configFiles)
             ? "Release metadata"
-            : summarizeFlowSubject(configFiles, "Changed", domainLanguage);
+            : (projectType === "expo-react-native" || projectType === "react-native") && configFiles.some(isMobileNativeConfigFile)
+                ? "Mobile build"
+                : summarizeFlowSubject(configFiles, "Changed", domainLanguage);
         candidates.push({
             kind: "config",
             title: `${subject} configuration verification ${runner === "manual" ? "checklist" : "flow"}`,
@@ -3309,7 +3389,10 @@ async function buildFlow(root, runner, candidate, testSuiteInventory, fixtureCon
     }
     const coverage = buildCoverageTargets(candidate.kind, files, runner);
     const setupHints = await inferFlowSetupHints(root, files, candidate.kind);
-    const selectors = await inferFlowSelectors(root, files, runner, addedDiffText);
+    const interactionEvidenceApplies = !isVerificationOnlyKind(candidate.kind);
+    const selectors = interactionEvidenceApplies
+        ? await inferFlowSelectors(root, files, runner, addedDiffText)
+        : [];
     const flow = {
         title: candidate.title,
         reason: candidate.reason,
@@ -3317,17 +3400,20 @@ async function buildFlow(root, runner, candidate, testSuiteInventory, fixtureCon
         steps: refineStepsForInferredSelectors(candidate.steps, selectors),
         coverage,
         coverageEvidence: evaluateFlowCoverageEvidence({ title: candidate.title, files, coverage }, testSuiteInventory),
-        entrypoints: await inferFlowEntrypoints(root, files, runner),
+        entrypoints: interactionEvidenceApplies ? await inferFlowEntrypoints(root, files, runner) : [],
         setupHints,
         fixtureReadiness: await inferFlowFixtureReadiness(root, files, candidate.kind, setupHints, fixtureContext),
         selectors,
-        missingTestability: await findFlowTestabilityGaps(root, files, runner),
+        missingTestability: interactionEvidenceApplies ? await findFlowTestabilityGaps(root, files, runner) : [],
     };
     return {
         ...flow,
         languageBrief: buildFlowLanguageBrief(flow),
     };
 }
+function isVerificationOnlyKind(kind) {
+    return kind === "config" || kind === "test-evidence" || kind === "documentation" || kind === "generated-artifact";
+}
 function preferDiffAdded(selectors, predicate) {
     return selectors.find((selector) => selector.addedInDiff && predicate(selector)) ?? selectors.find(predicate);
 }
@@ -3381,7 +3467,11 @@ function selectorStepLabel(selector) {
     return raw.length > 0 ? `"${raw}"` : `the ${selector.kind} control`;
 }
 function actionVerbForSelector(selector) {
-    if (/\b(?:submit|send|apply|complete|confirm|save|continue|next|upload)\b/i.test(selector.value.replace(/[-_]+/g, " "))) {
+    const normalized = selector.value.replace(/[-_]+/g, " ");
+    if (/\b(?:submit|send|apply|complete|confirm|save|continue|next|upload)\b/i.test(normalized)) {
+        return "Submit";
+    }
+    if (/(?:제출|저장|보내기|전송|등록|신청|결제|구매|확인|완료)/.test(normalized)) {
         return "Submit";
     }
     return "Activate";
@@ -3458,12 +3548,38 @@ function setupHint(kind, title, detail, files, confidence) {
         confidence,
     };
 }
+const maxAnalyzedMockFiles = 24;
 async function collectFixtureReadinessContext(root, changedFiles) {
     const projectFiles = await collectProjectFiles(root, 12000);
+    const changedMockFiles = changedFiles.filter(isMockOrFixtureFile).slice(0, maxFilesPerFlow);
+    const projectMockEntries = projectFiles.filter((file) => isMockOrFixtureFile(file.path));
+    // The project walk already loaded these files' text (with its own size and
+    // text-extension guards); parsing it here is what lets fixture guidance
+    // name concrete exports, handled routes, and keys.
+    const walkTexts = new Map(projectFiles.map((file) => [file.path, file.text]));
+    const mockFileInsights = new Map();
+    for (const file of changedMockFiles) {
+        let text = walkTexts.get(file);
+        if (text === undefined && fixtureEvidenceSourceExtensions.has(path.extname(file).toLowerCase())) {
+            text = await readTextIfExists(path.join(root, file));
+        }
+        if (text !== undefined) {
+            mockFileInsights.set(file, analyzeFixtureSource(file, text));
+        }
+    }
+    for (const file of projectMockEntries) {
+        if (mockFileInsights.size >= maxAnalyzedMockFiles) {
+            break;
+        }
+        if (!mockFileInsights.has(file.path) && file.text !== undefined) {
+            mockFileInsights.set(file.path, analyzeFixtureSource(file.path, file.text));
+        }
+    }
     return {
         changedBackendFiles: changedFiles.filter(isBackendImplementationFile).slice(0, maxFilesPerFlow),
-        changedMockFiles: changedFiles.filter(isMockOrFixtureFile).slice(0, maxFilesPerFlow),
-        projectMockFiles: projectFiles.map((file) => file.path).filter(isMockOrFixtureFile).slice(0, maxFilesPerFlow),
+        changedMockFiles,
+        projectMockFiles: projectMockEntries.map((file) => file.path).slice(0, maxFilesPerFlow),
+        mockFileInsights,
     };
 }
 async function inferFlowFixtureReadiness(root, files, kind, setupHints, context) {
@@ -3535,6 +3651,7 @@ async function inferFlowFixtureReadiness(root, files, kind, setupHints, context)
     const fallbackProjectMockSignals = projectMockSignals.length > 0 ? projectMockSignals : context.projectMockFiles;
     const mockSignals = uniqueStrings([...changedMockSignals, ...fallbackProjectMockSignals]).slice(0, maxFilesPerFlow);
     if (changedMockSignals.length > 0) {
+        const changedInsights = insightsForMockSignals(changedMockSignals, context);
         return {
             status: "ready",
             reason: "This branch includes mock or fixture evidence for an API-dependent flow.",
@@ -3543,13 +3660,15 @@ async function inferFlowFixtureReadiness(root, files, kind, setupHints, context)
             backendSignals,
             mockSignals,
             nextActions: [
-                `Keep changed fixture/mock evidence aligned with this flow: ${formatFileSummary(changedMockSignals)}.`,
+                `Keep changed fixture/mock evidence aligned with this flow: ${describeFixtureEvidence(changedMockSignals, changedInsights)}.`,
                 "Keep deterministic success, empty, unauthorized, and failure fixture cases aligned with the changed flow.",
             ],
+            ...(changedInsights.length > 0 ? { mockInsights: changedInsights } : {}),
         };
     }
     if (context.projectMockFiles.length > 0) {
         const reusableMockSignals = mockSignals.length > 0 ? mockSignals : context.projectMockFiles;
+        const reusableInsights = insightsForMockSignals(reusableMockSignals, context);
         return {
             status: "partial",
             reason: "Mock or fixture infrastructure exists, but this branch does not add flow-specific fixture evidence.",
@@ -3558,9 +3677,10 @@ async function inferFlowFixtureReadiness(root, files, kind, setupHints, context)
             backendSignals,
             mockSignals,
             nextActions: [
-                `Reuse or extend existing fixture/mock evidence for this flow: ${formatFileSummary(reusableMockSignals)}.`,
+                reuseFixtureAction(reusableMockSignals, reusableInsights, apiEndpoints),
                 "Cover the primary success response and one empty, rejected, or server-error response.",
             ],
+            ...(reusableInsights.length > 0 ? { mockInsights: reusableInsights } : {}),
         };
     }
     if (backendSignals.length > 0) {
@@ -3572,7 +3692,9 @@ async function inferFlowFixtureReadiness(root, files, kind, setupHints, context)
             backendSignals,
             mockSignals,
             nextActions: [
-                "Confirm the test environment can serve the changed API path, or add a mock response for local E2E runs.",
+                apiEndpoints.length > 0
+                    ? `Confirm the test environment can serve ${formatEndpointSummary(apiEndpoints)}, or add a mock response for local E2E runs.`
+                    : "Confirm the test environment can serve the changed API path, or add a mock response for local E2E runs.",
                 "Seed realistic response data for success and failure paths.",
             ],
         };
@@ -3585,11 +3707,59 @@ async function inferFlowFixtureReadiness(root, files, kind, setupHints, context)
         backendSignals,
         mockSignals,
         nextActions: [
-            "Add a deterministic mock or fixture response, such as MSW handlers, Playwright route fulfillment, mock data, or seeded test data.",
+            apiEndpoints.length > 0
+                ? `Add a deterministic mock or fixture response for ${formatEndpointSummary(apiEndpoints)}, such as an MSW handler, Playwright route fulfillment, mock data, or seeded test data.`
+                : "Add a deterministic mock or fixture response, such as MSW handlers, Playwright route fulfillment, mock data, or seeded test data.",
             "Include success plus one empty, unauthorized, rejected, timeout, or server-error response.",
         ],
     };
 }
+function insightsForMockSignals(mockSignals, context) {
+    return mockSignals
+        .map((file) => context.mockFileInsights.get(file))
+        .filter((insight) => insight !== undefined)
+        .slice(0, 3);
+}
+function describeFixtureEvidence(mockSignals, insights) {
+    if (insights.length === 0) {
+        return formatFileSummary(mockSignals);
+    }
+    return insights.map(describeFixtureFile).join("; ");
+}
+function describeFixtureFile(insight) {
+    if (insight.handledEndpoints.length > 0) {
+        return `${insight.file} (already handles ${formatEndpointSummary(insight.handledEndpoints)})`;
+    }
+    if (insight.exports.length > 0) {
+        return `${insight.file} (exports ${insight.exports.slice(0, 3).join(", ")})`;
+    }
+    return insight.file;
+}
+// Turns "reuse something somewhere" into "extend this file for these routes"
+// whenever the analyzed mock files give us that specificity.
+function reuseFixtureAction(reusableMockSignals, insights, apiEndpoints) {
+    if (insights.length === 0 || apiEndpoints.length === 0) {
+        return `Reuse or extend existing fixture/mock evidence for this flow: ${describeFixtureEvidence(reusableMockSignals, insights)}.`;
+    }
+    const uncovered = apiEndpoints.filter((endpoint) => !insights.some((insight) => insightCoversEndpoint(insight, endpoint)));
+    if (uncovered.length === 0) {
+        return `Wire the existing mock coverage into this flow's E2E run: ${describeFixtureEvidence(reusableMockSignals, insights)} for ${formatEndpointSummary(apiEndpoints)}.`;
+    }
+    const handlerInsight = insights.find((insight) => insight.handledEndpoints.length > 0);
+    if (handlerInsight) {
+        return `Extend ${describeFixtureFile(handlerInsight)} to also cover ${formatEndpointSummary(uncovered)}.`;
+    }
+    const exporterInsight = insights.find((insight) => insight.exports.length > 0);
+    if (exporterInsight) {
+        return `Reuse ${describeFixtureFile(exporterInsight)} to build a deterministic response for ${formatEndpointSummary(uncovered)}.`;
+    }
+    return `Reuse or extend existing fixture/mock evidence for ${formatEndpointSummary(uncovered)}: ${describeFixtureEvidence(reusableMockSignals, insights)}.`;
+}
+function formatEndpointSummary(endpoints) {
+    const shown = endpoints.slice(0, 3);
+    const remaining = endpoints.length - shown.length;
+    return remaining > 0 ? `${shown.join(", ")} and ${remaining} more` : shown.join(", ");
+}
 async function findApiDependencySignals(root, files, kind, setupHints) {
     const signals = new Set();
     if (kind === "api") {
@@ -3652,7 +3822,7 @@ function normalizeApiEndpointHint(value) {
     if (!/(?:\/api(?:\/|$)|\/graphql(?:\/|$)|\/trpc(?:\/|$))/i.test(endpoint)) {
         return undefined;
     }
-    if (/[\s<>{}]/.test(endpoint)) {
+    if (/[\s<>{}`]/.test(endpoint)) {
         return undefined;
     }
     return endpoint;
@@ -3697,10 +3867,40 @@ function isMockOrFixtureFile(file) {
     const stem = basename.replace(/\.[^.]+$/g, "");
     const extension = path.extname(basename).toLowerCase();
     const canUseBroadFilenameMatch = fixtureEvidenceSourceExtensions.has(extension);
-    return /(?:^|\/)(?:__mocks__|mocks?|fixtures?|factories|seeds?|test-data|testData|msw|mirage)\//i.test(file) ||
-        /(?:mock|fixture|factory|seed|handler|msw)\.[cm]?[jt]sx?$/i.test(basename) ||
-        (canUseBroadFilenameMatch && /(?:mock|fixture|factory|seed|msw|mirage)/i.test(stem));
-}
+    if (/(?:^|\/)(?:__mocks__|mocks?|fixtures?|factories|seeds?|test-data|testData|msw|mirage)\//i.test(file)) {
+        return true;
+    }
+    // Match whole name tokens, not substrings: demoSeedService, APIMockClient,
+    // and mock-users qualify, but a useSeedlingCatalog hook or an errorHandler
+    // utility does not. "handler" alone is an ordinary code word, so it only
+    // counts as mock evidence when the mock-ish directory rule above already
+    // matched. Derived -ing forms stay excluded on purpose: the canonical
+    // seed-data conventions (seeds/ and seeders/ directories, seed.* files)
+    // are already covered by the rules above, and an -ing filename is
+    // ambiguous between fixture data and application behavior — ambiguity
+    // must not count as mock evidence.
+    const stemTokens = stem
+        .split(/[^a-zA-Z0-9]+|(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/)
+        .map((token) => token.toLowerCase());
+    return canUseBroadFilenameMatch && stemTokens.some((token) => mockEvidenceNameTokens.has(token));
+}
+const mockEvidenceNameTokens = new Set([
+    "mock",
+    "mocks",
+    "mocked",
+    "mocking",
+    "fixture",
+    "fixtures",
+    "factory",
+    "factories",
+    "seed",
+    "seeds",
+    "seeded",
+    "seeder",
+    "seeders",
+    "msw",
+    "mirage",
+]);
 function isFixtureEvidenceIgnoredPath(file) {
     return /(?:^|\/)(?:node_modules|vendor|vendors|Pods|build|dist|coverage|\.next|\.nuxt|\.expo|\.turbo|\.yarn\/cache)\//i.test(file);
 }
@@ -4074,7 +4274,7 @@ async function buildSetupNotes(root, runner, project) {
     return ["Choose an E2E runner after documenting the primary user-facing entry point for this project."];
 }
 function isUserFacingFile(file) {
-    if (isApiRouteFile(file)) {
+    if (isApiRouteFile(file) || isConfigLikeFile(file) || isTestLikeFile(file)) {
         return false;
     }
     return (/(?:^|\/)(app|pages|routes|screens|components|ui|navigation)\//i.test(file) ||
@@ -4130,7 +4330,13 @@ function isCatalogDataFile(file) {
         /(?:^|\/)(?:catalog|taxonomy)-site\/index\.html$/i.test(file);
 }
 function isConfigLikeFile(file) {
-    return isReleaseMetadataFile(file) || /(?:(?:^|\/)(?:\.agents?|\.claude|\.cursor|\.dev|\.gemini|\.github|docs?)\/|(?:^|\/)(?:AGENTS|CLAUDE|CODEX|DECISIONS|GEMINI|PLAN|README|SKILL)\.md$|\.gitignore|package\.json|pnpm-lock\.yaml|yarn\.lock|package-lock\.json|bun\.lockb|pyproject\.toml|requirements\.txt|go\.mod|go\.sum|Cargo\.toml|Cargo\.lock|pom\.xml|build\.gradle|gradle\.properties|vite|webpack|babel|tsconfig|next\.config|app\.config|eas\.json|release-please|docker|env|feature-?flags?|experiments?)/i.test(file);
+    return isReleaseMetadataFile(file) || isMobileNativeConfigFile(file) || /(?:(?:^|\/)(?:\.agents?|\.claude|\.cursor|\.dev|\.gemini|\.github|docs?)\/|(?:^|\/)(?:AGENTS|CLAUDE|CODEX|DECISIONS|GEMINI|PLAN|README|SKILL)\.md$|\.gitignore|package\.json|pnpm-lock\.yaml|yarn\.lock|package-lock\.json|bun\.lockb|pyproject\.toml|requirements\.txt|go\.mod|go\.sum|Cargo\.toml|Cargo\.lock|pom\.xml|build\.gradle|gradle\.properties|vite|webpack|babel|tsconfig|next\.config|app\.config|eas\.json|release-please|docker|env|feature-?flags?|experiments?)/i.test(file);
+}
+function isMobileNativeConfigFile(file) {
+    return /(?:^|\/)(?:app\.json|eas\.json|Podfile(?:\.lock)?|Info\.plist|project\.pbxproj|AndroidManifest\.xml|[^/]+\.entitlements)$/i.test(file) ||
+        /(?:^|\/)app\.config\.[cm]?[jt]s$/i.test(file) ||
+        /(?:^|\/)android\/.+\.(?:gradle|properties)$/i.test(file) ||
+        /(?:^|\/)ios\/[^/]+\.xcodeproj\/project\.pbxproj$/i.test(file);
 }
 function isReleaseMetadataFile(file) {
     return /(?:^|\/)(?:CHANGELOG|RELEASES?|release-notes?|\.release-please-manifest)\.(?:md|json)$/i.test(file) ||
@@ -4163,7 +4369,11 @@ function isTestLikeFile(file) {
         /(?:^|\/)test_[^/]+\.py$/i.test(file) ||
         /(?:^|\/)[^/]+_test\.(?:py|go)$/i.test(file) ||
         /(?:^|\/)[^/]+(?:Test|Tests|Spec)\.(?:java|kt|cs|swift)$/i.test(file) ||
-        /(?:^|\/)[^/]+_(?:test|spec)\.rs$/i.test(file));
+        /(?:^|\/)[^/]+_(?:test|spec)\.rs$/i.test(file) ||
+        /(?:^|\/)\.maestro\/[^/]+\.ya?ml$/i.test(file));
+}
+function isConfigurationOnlyChange(files) {
+    return files.length > 0 && files.every(isConfigLikeFile);
 }
 function isDocumentationFile(file) {
     if (isReleaseMetadataFile(file)) {
@@ -4534,7 +4744,7 @@ function isImportantBaseDraftFlow(flow) {
 }
 function shouldUseDomainScenariosForDraft(plan) {
     const files = plan.changedFiles.map((file) => file.path);
-    if (isLowSignalVerificationOnlyChange(files)) {
+    if (isLowSignalVerificationOnlyChange(files) || isConfigurationOnlyChange(files)) {
         return false;
     }
     return !plan.flows.every(isEvidenceVerificationFocusedFlow);
@@ -4542,6 +4752,9 @@ function shouldUseDomainScenariosForDraft(plan) {
 function isEvidenceVerificationFocusedFlow(flow) {
     return isTestEvidenceFocusedFlow(flow) || isDocumentationFocusedFlow(flow) || isGeneratedArtifactFocusedFlow(flow);
 }
+function isVerificationOnlyFlow(flow) {
+    return isEvidenceVerificationFocusedFlow(flow) || /\bconfiguration verification\b/i.test(flow.title);
+}
 function dedupeDraftFlowsByOutputPath(flows, runner) {
     const flowsByOutput = new Map();
     for (const flow of flows) {
@@ -4736,7 +4949,11 @@ async function buildDomainScenarioDraftFlow(plan, scenario, baseFlows) {
     const reason = specializedScenario?.reason ?? scenario.intent;
     const steps = specializedScenario?.steps ?? (scenario.checks.length > 0 ? scenario.checks : (baseFlow?.steps ?? []));
     const scenarioFiles = normalizeScenarioFilesForRoot(plan, scenario.files);
-    const files = uniqueStrings(scenarioFiles.length > 0 ? scenarioFiles : (baseFlow?.files ?? [])).slice(0, 20);
+    const files = uniqueStrings(specializedScenario?.useBaseFlowFiles
+        ? [...(baseFlow?.files ?? []), ...scenarioFiles]
+        : scenarioFiles.length > 0
+            ? scenarioFiles
+            : (baseFlow?.files ?? [])).slice(0, 20);
     const coverage = baseFlow?.coverage ?? buildCoverageTargets("domain", files, plan.recommendedRunner.name);
     const runner = plan.recommendedRunner.name;
     const entrypoints = uniqueEntrypoints([
@@ -4788,6 +5005,15 @@ function specializedDomainScenarioDraft(scenario, baseFlow) {
     if (scenario.source !== "changed-file" || !baseFlow) {
         return undefined;
     }
+    if (/through imports/i.test(baseFlow.reason) && /\sprimary journey$/i.test(scenario.title)) {
+        const subject = baseFlow.title.replace(/\s+UI smoke flow$/i, "").trim();
+        return {
+            title: subject,
+            reason: baseFlow.reason,
+            steps: baseFlow.steps,
+            useBaseFlowFiles: true,
+        };
+    }
     if (isApiContractFocusedFlow(baseFlow)) {
         const subject = scenario.title.replace(/\s+primary journey$/i, "");
         return {
@@ -4939,7 +5165,7 @@ function domainScenarioForFlow(flow) {
     return flow.domainScenario;
 }
 function draftStability(plan, flow) {
-    const needsSelector = flow.missingTestability.length > 0;
+    const needsSelector = !isVerificationOnlyFlow(flow) && flow.missingTestability.length > 0;
     const needsSetup = plan.missingTestability.some((gap) => /No \.maestro|No Playwright config/i.test(gap));
     if (needsSelector && needsSetup) {
         return "needs-selector-and-setup";
@@ -4953,14 +5179,15 @@ function draftStability(plan, flow) {
     return "ready";
 }
 function draftExecutionBlockers(plan, flow, runner, validationSummary, selfCheck) {
-    const blockers = [...plan.executionProfile.blockers];
-    if (runner !== "manual" && flow.entrypoints.length === 0) {
+    const verificationOnly = isVerificationOnlyFlow(flow);
+    const blockers = verificationOnly ? [] : [...plan.executionProfile.blockers];
+    if (!verificationOnly && runner !== "manual" && flow.entrypoints.length === 0) {
         blockers.push("No runnable route, screen, or command entrypoint was inferred for this flow.");
     }
-    if (flow.missingTestability.length > 0) {
+    if (!verificationOnly && flow.missingTestability.length > 0) {
         blockers.push(flow.missingTestability[0]);
     }
-    if (flow.fixtureReadiness.status === "missing") {
+    if (!verificationOnly && flow.fixtureReadiness.status === "missing") {
         blockers.push(flow.fixtureReadiness.nextActions[0] ?? flow.fixtureReadiness.reason);
     }
     if (validationSummary.blockingGapCount > 0) {
@@ -4972,7 +5199,7 @@ function draftExecutionBlockers(plan, flow, runner, validationSummary, selfCheck
     return uniqueStrings(blockers).slice(0, 8);
 }
 function draftRunnableStatus(plan, flow, runner, validationSummary, executionBlockers, selfCheck) {
-    if (runner === "manual") {
+    if (runner === "manual" || isVerificationOnlyFlow(flow)) {
         return "review-only";
     }
     if (selfCheck?.status === "fail") {
@@ -5212,12 +5439,12 @@ function draftExtension(runner) {
     }
     return ".md";
 }
-function draftContentForFlow(plan, flow, runner) {
+function draftContentForFlow(plan, flow, runner, addedDiffText = {}) {
     if (runner === "maestro") {
         return buildMaestroDraft(plan, flow);
     }
     if (runner === "playwright") {
-        return buildPlaywrightDraft(plan, flow);
+        return buildPlaywrightDraft(plan, flow, addedDiffText);
     }
     return buildManualDraft(plan, flow);
 }
@@ -5310,7 +5537,7 @@ function maestroCommandForStep(step, selectors) {
         value: maestroSelectorValue(selector),
     };
 }
-function buildPlaywrightDraft(plan, flow) {
+function buildPlaywrightDraft(plan, flow, addedDiffText = {}) {
     const testName = flow.title.replaceAll('"', "'");
     const selectorQueue = [...flow.selectors];
     const scenario = domainScenarioForFlow(flow);
@@ -5367,6 +5594,7 @@ function buildPlaywrightDraft(plan, flow) {
                 : playwrightFallbackActionForStep(step));
         appendPlaywrightTestStep(lines, step, body);
     }
+    appendObservedResponseAssertion(lines, flow, addedDiffText);
     appendDomainScenarioComments(lines, flow, "  //");
     appendPlaywrightCoverageComments(lines, flow);
     lines.push("});");
@@ -5964,12 +6192,7 @@ function appendPlaywrightMockRouteScaffold(lines, flow) {
     if (flow.fixtureReadiness.status === "not-needed" || flow.fixtureReadiness.apiEndpoints.length === 0) {
         return;
     }
-    const changedEndpointHints = uniqueStrings(flow.fixtureReadiness.backendSignals.flatMap(apiEndpointFromBackendFile));
-    const observedEndpoints = changedEndpointHints.length > 0
-        ? changedEndpointHints
-        : flow.fixtureReadiness.backendSignals.length > 0
-            ? flow.fixtureReadiness.apiEndpoints
-            : [];
+    const observedEndpoints = observedEndpointsForFlow(flow);
     if (observedEndpoints.length > 0) {
         appendPlaywrightApiObservationScaffold(lines, observedEndpoints);
     }
@@ -5979,19 +6202,39 @@ function appendPlaywrightMockRouteScaffold(lines, flow) {
     if (mockableEndpoints.length === 0) {
         return;
     }
+    const insights = flow.fixtureReadiness.mockInsights ?? [];
+    const shapeSources = [];
     lines.push("");
     lines.push("  const mockApiResponses = {");
     for (const endpoint of mockableEndpoints.slice(0, maxFilesPerFlow)) {
+        const insight = insights.find((candidate) => specSafeSampleKeys(candidate).length > 0 && insightCoversEndpoint(candidate, endpoint)) ??
+            insights.find((candidate) => specSafeSampleKeys(candidate).length > 0);
         lines.push(`    "${quoteJs(playwrightMockRoutePattern(endpoint))}": {`);
         lines.push("      status: 200,");
         lines.push("      body: {");
-        lines.push('        ok: true,');
-        lines.push('        source: "qamap-draft",');
+        if (insight) {
+            if (!shapeSources.includes(insight.file)) {
+                shapeSources.push(insight.file);
+            }
+            for (const key of specSafeSampleKeys(insight)) {
+                const propertyName = isJsIdentifier(key) ? key : JSON.stringify(key);
+                lines.push(`        ${propertyName}: ${JSON.stringify(`qamap-${key}`)},`);
+            }
+        }
+        else {
+            lines.push('        ok: true,');
+            lines.push('        source: "qamap-draft",');
+        }
         lines.push("      },");
         lines.push("    },");
     }
     lines.push("  };");
-    lines.push("  // Replace sample responses with deterministic fixtures from the target domain before promoting this draft.");
+    if (shapeSources.length > 0) {
+        lines.push(`  // Response shape keys reuse ${formatFileSummary(shapeSources)}; replace the sample values with deterministic fixture data before promoting this draft.`);
+    }
+    else {
+        lines.push("  // Replace sample responses with deterministic fixtures from the target domain before promoting this draft.");
+    }
     lines.push("  for (const [urlPattern, response] of Object.entries(mockApiResponses)) {");
     lines.push("    await page.route(urlPattern, async (route) => {");
     lines.push("      await route.fulfill({");
@@ -6002,6 +6245,71 @@ function appendPlaywrightMockRouteScaffold(lines, flow) {
     lines.push("    });");
     lines.push("  }");
 }
+// Drafts are pinned to contain no literal TODO marker, so a fixture key that
+// would introduce one disqualifies itself from spec interpolation.
+function specSafeSampleKeys(insight) {
+    return insight.sampleKeys.filter((key) => !/todo/i.test(key));
+}
+function observedEndpointsForFlow(flow) {
+    if (flow.fixtureReadiness.status === "not-needed" || flow.fixtureReadiness.apiEndpoints.length === 0) {
+        return [];
+    }
+    const changedEndpointHints = uniqueStrings(flow.fixtureReadiness.backendSignals.flatMap(apiEndpointFromBackendFile));
+    if (changedEndpointHints.length > 0) {
+        return changedEndpointHints;
+    }
+    return flow.fixtureReadiness.backendSignals.length > 0 ? flow.fixtureReadiness.apiEndpoints : [];
+}
+function collectChangedHandlerEvidence(flow, addedDiffText) {
+    const statuses = [];
+    const responseKeys = [];
+    for (const file of flow.fixtureReadiness.backendSignals) {
+        const addedText = addedDiffText[file];
+        if (!addedText) {
+            continue;
+        }
+        for (const match of addedText.matchAll(/(?:status[:(]\s*|\.status\(\s*)(\d{3})\b/g)) {
+            const status = Number(match[1]);
+            if (status >= 100 && status < 600) {
+                statuses.push(status);
+            }
+        }
+        for (const match of addedText.matchAll(/(?:NextResponse|Response|res)\.json\(\s*\{([^}]{1,200})\}/g)) {
+            for (const keyMatch of match[1].matchAll(/(?:^|[,{])\s*([A-Za-z_$][\w$]*)\s*[:,}]/g)) {
+                responseKeys.push(keyMatch[1]);
+            }
+        }
+    }
+    const uniqueStatuses = [...new Set(statuses)];
+    return {
+        statuses: uniqueStatuses,
+        successOnly: uniqueStatuses.length > 0 && uniqueStatuses.every((status) => status < 400),
+        responseKeys: [...new Set(responseKeys)].slice(0, 6),
+    };
+}
+function appendObservedResponseAssertion(lines, flow, addedDiffText) {
+    if (observedEndpointsForFlow(flow).length === 0) {
+        return;
+    }
+    const evidence = collectChangedHandlerEvidence(flow, addedDiffText);
+    const statusCeiling = evidence.successOnly ? 400 : 500;
+    lines.push("");
+    if (evidence.successOnly) {
+        lines.push(`  // The added handler code only shows success statuses (${evidence.statuses.join(", ")}), so any 4xx/5xx here is unexpected.`);
+    }
+    else {
+        lines.push("  // Changed-endpoint check: the journey must not surface server errors from the code under test.");
+    }
+    if (evidence.responseKeys.length > 0) {
+        lines.push(`  // Response shape hint from the changed handler: { ${evidence.responseKeys.join(", ")} } — assert on these fields when promoting this draft.`);
+    }
+    lines.push("  for (const response of observedChangedApiResponses) {");
+    lines.push(`    expect(response.status, \`unexpected status from \${response.url}\`).toBeLessThan(${statusCeiling});`);
+    lines.push("  }");
+    lines.push("  if (observedChangedApiResponses.length === 0) {");
+    lines.push('    console.warn("Changed endpoints were not exercised by this draft; extend the steps above to cover them.");');
+    lines.push("  }");
+}
 function appendPlaywrightApiObservationScaffold(lines, endpoints) {
     lines.push("");
     lines.push("  const changedApiEndpointPatterns = [");
@@ -6703,7 +7011,7 @@ function withoutSelectorValueDuplicates(selectors, existing) {
 function extractAttributeSelectors(file, text, attributes, kind) {
     const selectors = [];
     for (const attribute of attributes) {
-        const matcher = new RegExp(`${escapeRegExp(attribute)}\\s*=\\s*(?:"([^"]+)"|'([^']+)'|\\{\\s*["'\`]([^"'\`{}]+)["'\`]\\s*\\})`, "g");
+        const matcher = new RegExp(`(?<![:@.\\w-])${escapeRegExp(attribute)}\\s*=\\s*(?:"([^"]+)"|'([^']+)'|\\{\\s*["'\`]([^"'\`{}]+)["'\`]\\s*\\})`, "g");
         for (const match of text.matchAll(matcher)) {
             const value = normalizeSelectorValue(match[1] ?? match[2] ?? match[3]);
             if (value) {
@@ -6732,6 +7040,28 @@ function extractTextNodeSelectors(file, text) {
     for (const selector of extractAttributeSelectors(file, text, ["title"], "visible-text")) {
         selectors.push(selector);
     }
+    selectors.push(...extractRenderedStateSelectors(file, text));
+    return selectors;
+}
+function extractRenderedStateSelectors(file, text) {
+    const selectors = [];
+    const renderedNames = new Set([...text.matchAll(/>\s*\{\s*([A-Za-z_$][\w$]*)\s*\}\s*</g)].map((match) => match[1]));
+    for (const stateName of renderedNames) {
+        const stateDeclaration = new RegExp(`\\bconst\\s*\\[\\s*${escapeRegExp(stateName)}\\s*,\\s*([A-Za-z_$][\\w$]*)\\s*\\]\\s*=\\s*useState\\b`).exec(text);
+        const setterName = stateDeclaration?.[1];
+        if (!setterName) {
+            continue;
+        }
+        const setterCallMatcher = new RegExp(`\\b${escapeRegExp(setterName)}\\s*\\(([^\\n;]{0,300})\\)`, "g");
+        for (const call of text.matchAll(setterCallMatcher)) {
+            for (const literal of call[1].matchAll(/"([^"]+)"|'([^']+)'|`([^`]+)`/g)) {
+                const value = normalizeSelectorValue(literal[1] ?? literal[2] ?? literal[3]);
+                if (value && isUsefulSelector(value)) {
+                    selectors.push({ kind: "visible-text", value, file });
+                }
+            }
+        }
+    }
     return selectors;
 }
 function extractRoleSelectorsFromText(file, text) {
@@ -6761,7 +7091,15 @@ function normalizeSelectorValue(value) {
     return normalized || undefined;
 }
 function isUsefulSelector(value) {
-    return value.length >= 2 && value.length <= 80 && !/[{}()[\]=>]/.test(value);
+    if (value.length < 2 || value.length > 80 || /[{}()[\]=>]/.test(value)) {
+        return false;
+    }
+    // Dotted tokens without spaces are almost always i18n keys or property paths,
+    // never rendered UI text, so a locator built from them can never match.
+    if (/^[\w$-]+(?:\.[\w$-]+)+$/.test(value)) {
+        return false;
+    }
+    return true;
 }
 async function readPackageJson(root) {
     try {
@@ -6981,11 +7319,12 @@ function selectorRank(kind) {
     return 4;
 }
 function slugify(value) {
-    return value
+    const slug = value
         .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/[^a-z0-9\uAC00-\uD7A3]+/g, "-")
         .replace(/^-+|-+$/g, "")
         .slice(0, 80);
+    return slug || "draft";
 }
 function quoteYaml(value) {
     return JSON.stringify(value);