@ivorycanvas/qamap 0.3.4 → 0.4.0

package/dist/e2e.js

@@ -1,6 +1,10 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import YAML from "yaml";
+import { analyzeBehaviorGraph, createInferredFlowBehaviorAdapter } from "./behavior.js";
+import { createChangeIntentBehaviorAdapter } from "./behavior-intent.js";
+import { createManifestBehaviorAdapter } from "./behavior-manifest.js";
+import { analyzeChangeIntents } from "./change-intent.js";
 import { buildDomainLanguageSummary } from "./domain-language.js";
 import { defaultDomainManifestPath, loadDomainManifest, matchDomains } from "./domains.js";
 import { analyzeFixtureSource, insightCoversEndpoint } from "./fixture-insight.js";
@@ -65,9 +69,35 @@ export async function generateE2ePlan(rootInput, options = {}) {
         workspaceRoot: testPlan.workspaceRoot,
         includeWorkingTree: options.includeWorkingTree,
     });
+    const changeAnalysis = await analyzeChangeIntents(root, {
+        base: testPlan.base,
+        head: testPlan.head,
+        workspaceRoot: testPlan.workspaceRoot,
+        includeWorkingTree: options.includeWorkingTree,
+        changedFiles: testPlan.changedFiles,
+        addedDiffText,
+    });
     const domainLanguage = await buildDomainLanguageSummary(root, testPlan.changedFiles, coreFlows, domains, addedDiffText);
     const workspaceTargets = await buildWorkspaceTargets(root, testPlan);
-    const flows = await buildFlows(root, testPlan.changedFiles, recommendedRunner.name, project.type, testSuiteInventory, domainLanguage, addedDiffText);
+    const flows = await buildFlows(root, testPlan.changedFiles, recommendedRunner.name, project.type, testSuiteInventory, domainLanguage, addedDiffText, changeAnalysis);
+    const behaviorGraph = await analyzeBehaviorGraph({
+        root: testPlan.root,
+        workspaceRoot: testPlan.workspaceRoot,
+        base: testPlan.base,
+        head: testPlan.head,
+        projectType: project.type,
+        surface: behaviorSurfaceForProject(project.type),
+        runner: recommendedRunner.name,
+        changedFiles: testPlan.changedFiles.map((file) => ({
+            path: file.path,
+            status: file.status,
+            previousPath: file.previousPath,
+        })),
+    }, [
+        createInferredFlowBehaviorAdapter({ flows: flows.map(toInferredBehaviorFlow) }),
+        createChangeIntentBehaviorAdapter({ analysis: changeAnalysis }),
+        createManifestBehaviorAdapter({ matches: verificationManifestMatches }),
+    ]);
     const testSuite = summarizeTestSuiteInventory(testSuiteInventory);
     const missingTestability = uniqueStrings([
         ...flows.flatMap((flow) => flow.missingTestability),
@@ -118,16 +148,50 @@ export async function generateE2ePlan(rootInput, options = {}) {
         verificationManifestPath: verificationManifest.path,
         verificationManifestMatches,
         domainLanguage,
+        changeAnalysis,
         changedFiles: testPlan.changedFiles,
         suggestedCommands: testPlan.suggestedCommands,
         workspaceTargets,
         flows,
+        behaviorGraph,
         validationMatrix,
         bootstrap,
         missingTestability,
         setupNotes,
     };
 }
+function behaviorSurfaceForProject(projectType) {
+    if (projectType === "web") {
+        return "web";
+    }
+    if (projectType === "expo-react-native" || projectType === "react-native") {
+        return "mobile";
+    }
+    if (projectType === "api-service") {
+        return "api";
+    }
+    if (projectType === "cli") {
+        return "cli";
+    }
+    if (projectType === "design-tokens" || projectType === "data-catalog") {
+        return "artifact";
+    }
+    return "unknown";
+}
+function toInferredBehaviorFlow(flow) {
+    return {
+        kind: flow.kind ?? "changed-file",
+        title: flow.title,
+        reason: flow.reason,
+        files: flow.files,
+        steps: flow.steps,
+        entrypoints: flow.entrypoints,
+        selectors: flow.selectors,
+        coverage: flow.coverage,
+        fixtureStatus: flow.fixtureReadiness.status,
+        fixtureFiles: flow.fixtureReadiness.mockInsights?.map((insight) => insight.file) ?? [],
+    };
+}
 export async function generateE2eDraft(rootInput, options = {}) {
     const root = path.resolve(rootInput);
     const plan = await generateE2ePlan(root, options);
@@ -1025,6 +1089,10 @@ function draftFileDetails(flow) {
         setupHints: flow.setupHints.map((hint) => `${hint.title}: ${hint.detail}`).slice(0, 6),
         coverageTargets: flow.coverage.map((target) => `${target.priority}: ${target.title}`).slice(0, 7),
         manifestUpdatePath: flow.manifestMatch?.updatePath,
+        intentId: flow.intentId,
+        intentConfidence: flow.intentConfidence,
+        lifecycle: flow.lifecycle,
+        qaScenarios: flow.qaScenarios,
     };
 }
 function formatEntrypointHint(entrypoint) {
@@ -1227,6 +1295,35 @@ function withTerminalPeriod(value) {
 }
 function buildFlowLanguageBrief(flow) {
     const actor = inferFlowActor(flow);
+    if (flow.intentId && flow.lifecycle && flow.lifecycle.length > 0) {
+        const trigger = flow.lifecycle.find((stage) => stage.kind === "trigger")?.label ?? `Start the changed ${flow.title} behavior.`;
+        const outcomes = flow.lifecycle
+            .filter((stage) => stage.kind === "observable-outcome")
+            .map((stage) => stripTerminalPunctuation(stage.label));
+        const effects = flow.lifecycle
+            .filter((stage) => stage.kind === "side-effect")
+            .map((stage) => stripTerminalPunctuation(stage.label));
+        const lifecycleSuccessSignal = outcomes.length > 0
+            ? outcomes.slice(0, 2).join("; ")
+            : effects.length > 0
+                ? `the intended side effect completes: ${effects.slice(0, 2).join("; ")}`
+                : "the observable result matches the commit intent";
+        const repositorySuccessSignal = inferFlowSuccessSignal(flow);
+        const successSignal = repositorySuccessSignal === "the changed journey reaches a visible, stable success state"
+            ? lifecycleSuccessSignal
+            : repositorySuccessSignal;
+        const scenarioEdges = (flow.qaScenarios ?? [])
+            .filter((scenario) => scenario.kind !== "primary")
+            .flatMap((scenario) => [scenario.title, ...scenario.edgeCases]);
+        return {
+            actor,
+            trigger,
+            goal: `Complete the intended behavior: ${flow.title}.`,
+            successSignal,
+            reviewQuestion: `Does ${flow.title} follow the inferred lifecycle and produce this outcome: ${successSignal}?`,
+            edgeCases: uniqueStrings(scenarioEdges).slice(0, 6),
+        };
+    }
     const trigger = inferFlowTrigger(flow);
     const goal = inferFlowGoal(flow);
     const successSignal = inferFlowSuccessSignal(flow);
@@ -1417,8 +1514,8 @@ 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);
+    return /\b(?:confirmed|saved|scheduled|refreshed|succeeded|success|completed|created|updated|deleted|sent|approved|accepted)\b/i.test(value) ||
+        /(?:완료|성공|예약(?:됨|됐|되)|저장(?:됨|됐|되)|등록(?:됨|됐|되)|제출(?:됨|됐|되)|승인(?:됨|됐|되))/.test(value);
 }
 function inferFlowReviewQuestion(flow, successSignal) {
     if (isApiContractFocusedFlow(flow)) {
@@ -1519,7 +1616,7 @@ export function formatMarkdownE2ePlan(result) {
         lines.push("- Includes working tree changes: yes");
     }
     lines.push(`- Project: ${formatProjectType(result.project.type)}`);
-    lines.push(`- Recommended runner: ${formatRunnerName(result.recommendedRunner.name)}`);
+    lines.push(`- Automation adapter: ${formatRunnerName(result.recommendedRunner.name)}`);
     lines.push(`- Test suite: ${result.testSuite.hasTestSuite ? `${result.testSuite.testFileCount} test file${result.testSuite.testFileCount === 1 ? "" : "s"}` : "not detected"}`);
     if (result.testSuite.frameworkSignals.length > 0) {
         lines.push(`- Test frameworks: ${result.testSuite.frameworkSignals.join(", ")}`);
@@ -1544,7 +1641,10 @@ export function formatMarkdownE2ePlan(result) {
         lines.push(`- Local history: \`${escapeMarkdownInline(result.localHistory.path)}\``);
     }
     lines.push("");
-    lines.push("## Recommendation");
+    appendChangeIntentMarkdown(lines, result.changeAnalysis);
+    lines.push("## Automation Adapter");
+    lines.push("");
+    lines.push("QAMap selects an output adapter only after deriving runner-independent change intent and QA scenarios.");
     lines.push("");
     lines.push(result.recommendedRunner.reason);
     if (result.project.evidence.length > 0) {
@@ -1788,6 +1888,53 @@ export function formatMarkdownE2ePlan(result) {
     }
     return lines.join("\n");
 }
+function appendChangeIntentMarkdown(lines, analysis) {
+    lines.push("## Change Intent And Behavior Lifecycle");
+    lines.push("");
+    if (analysis.intents.length === 0) {
+        lines.push("No evidence-backed change intent was inferred. QAMap keeps heuristic flow suggestions review-only.");
+        for (const diagnostic of analysis.diagnostics.slice(0, 3)) {
+            lines.push(`- ${escapeMarkdownInline(diagnostic)}`);
+        }
+        lines.push("");
+        return;
+    }
+    for (const intent of analysis.intents.slice(0, 3)) {
+        lines.push(`### ${escapeMarkdownInline(intent.title)}`);
+        lines.push("");
+        lines.push(`- Confidence: ${intent.confidence}${intent.reviewRequired ? "; human review required" : ""}`);
+        lines.push(`- Summary: ${escapeMarkdownInline(intent.summary)}`);
+        if (intent.commits.length > 0) {
+            lines.push("- Commit evidence:");
+            for (const commit of intent.commits.slice(0, 6)) {
+                lines.push(`  - \`${commit.sha.slice(0, 12)}\` ${escapeMarkdownInline(commit.subject)}`);
+            }
+        }
+        if (intent.files.length > 0) {
+            lines.push(`- Source scope: ${intent.files.slice(0, 6).map((file) => `\`${escapeMarkdownInline(file)}\``).join(", ")}`);
+        }
+        lines.push("");
+        lines.push("Behavior lifecycle:");
+        intent.lifecycle.slice(0, 12).forEach((stage, index) => {
+            lines.push(`${index + 1}. **${stage.kind}**: ${escapeMarkdownInline(stage.label)} [${stage.confidence}]`);
+        });
+        lines.push("");
+        lines.push("Required QA scenarios:");
+        for (const scenario of intent.scenarios.slice(0, 4)) {
+            lines.push(`- **${scenario.priority} / ${scenario.kind}**: ${escapeMarkdownInline(scenario.title)}`);
+            for (const step of scenario.steps.slice(0, 3)) {
+                lines.push(`  - Step: ${escapeMarkdownInline(step)}`);
+            }
+            for (const assertion of scenario.assertions.slice(0, 3)) {
+                lines.push(`  - Assert: ${escapeMarkdownInline(assertion)}`);
+            }
+            if (scenario.edgeCases.length > 0) {
+                lines.push(`  - Boundaries: ${scenario.edgeCases.slice(0, 4).map(escapeMarkdownInline).join(", ")}`);
+            }
+        }
+        lines.push("");
+    }
+}
 function appendVerificationManifestMatchesMarkdown(lines, matches) {
     if (matches.length === 0) {
         return;
@@ -1833,7 +1980,7 @@ export function formatMarkdownE2eDraft(result) {
     lines.push("# QAMap E2E Draft");
     lines.push("");
     lines.push(`- Root: \`${escapeMarkdownInline(result.root)}\``);
-    lines.push(`- Runner: ${formatRunnerName(result.runner)}`);
+    lines.push(`- Automation adapter: ${formatRunnerName(result.runner)}`);
     lines.push(`- Output directory: \`${escapeMarkdownInline(result.outputDirectory)}\``);
     if (result.dryRun) {
         lines.push("- Mode: dry run (no files were written)");
@@ -1863,6 +2010,7 @@ export function formatMarkdownE2eDraft(result) {
         lines.push(`- Action categories: ${formatDraftActionKindSummary(result.actionSummary.byKind)}`);
     }
     lines.push("");
+    appendChangeIntentMarkdown(lines, result.plan.changeAnalysis);
     appendVerificationManifestMatchesMarkdown(lines, result.plan.verificationManifestMatches);
     lines.push("## Files");
     lines.push("");
@@ -2111,8 +2259,9 @@ async function detectProjectProfile(root, workspaceRoot) {
         "admin.py",
     ]);
     const projectFilePaths = (await collectProjectFiles(root, 2000)).map((file) => file.path);
-    const hasDesignTokenProject = projectFilePaths.some(isDesignTokenFile);
-    const hasDataCatalogProject = projectFilePaths.some(isCatalogDataFile);
+    const projectProfileArtifactFiles = projectFilePaths.filter((file) => !isTestLikeFile(file));
+    const hasDesignTokenProject = projectProfileArtifactFiles.some(isDesignTokenFile);
+    const hasDataCatalogProject = projectProfileArtifactFiles.some(isCatalogDataFile);
     const hasCliBin = packageJsonHasCliBin(packageJson);
     if (hasExpoDependency) {
         evidence.push("package.json dependency: expo");
@@ -2171,15 +2320,15 @@ async function detectProjectProfile(root, workspaceRoot) {
     if (apiServiceDependency || hasApiServiceConfig || hasDjangoEntrypoint || hasPythonServiceDependency || hasPythonServiceModule) {
         return { type: "api-service", evidence };
     }
+    if (hasCliBin) {
+        return { type: "cli", evidence };
+    }
     if (hasDesignTokenProject) {
         return { type: "design-tokens", evidence };
     }
     if (hasDataCatalogProject) {
         return { type: "data-catalog", evidence };
     }
-    if (hasCliBin) {
-        return { type: "cli", evidence };
-    }
     return {
         type: "unknown",
         evidence,
@@ -3057,11 +3206,11 @@ function toCoreFlowChangedFiles(changedFiles, scopedRoot, coreFlowRoot) {
         previousPath: file.previousPath ? toPosixPath(path.join(relativeRoot, file.previousPath)) : undefined,
     }));
 }
-async function buildFlows(root, changedFiles, runner, projectType, testSuiteInventory, domainLanguage, addedDiffText = {}) {
+async function buildFlows(root, changedFiles, runner, projectType, testSuiteInventory, domainLanguage, addedDiffText = {}, changeAnalysis) {
     const files = changedFiles.map((file) => file.path);
     const importImpacts = await collectImportImpacts(root, files);
     const fixtureContext = await collectFixtureReadinessContext(root, files);
-    const flowResults = await Promise.all(buildFlowCandidates(files, runner, projectType, domainLanguage, importImpacts).map((candidate) => buildFlow(root, runner, candidate, testSuiteInventory, fixtureContext, addedDiffText)));
+    const flowResults = await Promise.all(buildFlowCandidates(files, runner, projectType, domainLanguage, importImpacts, changeAnalysis).map((candidate) => buildFlow(root, runner, candidate, testSuiteInventory, fixtureContext, addedDiffText)));
     const flows = flowResults.filter((flow) => Boolean(flow));
     return dedupeFlows(flows).slice(0, 4);
 }
@@ -3106,7 +3255,7 @@ async function collectImportImpacts(root, changedFiles) {
 function describeImportChain(impact) {
     return impact.chain.join(" -> ");
 }
-function buildFlowCandidates(files, runner, projectType, domainLanguage, importImpacts = []) {
+function buildFlowCandidates(files, runner, projectType, domainLanguage, importImpacts = [], changeAnalysis) {
     const lowSignalCandidate = importImpacts.length === 0 ? buildLowSignalChangeCandidate(files) : undefined;
     if (lowSignalCandidate) {
         return [lowSignalCandidate];
@@ -3311,7 +3460,58 @@ function buildFlowCandidates(files, runner, projectType, domainLanguage, importI
             ],
         });
     }
-    return candidates;
+    return prioritizeChangeIntentCandidates(changeAnalysis, candidates, projectType);
+}
+function prioritizeChangeIntentCandidates(analysis, heuristicCandidates, projectType) {
+    const intentCandidates = (analysis?.intents ?? [])
+        .filter((intent) => intent.confidence !== "low" && intent.files.length > 0)
+        .map((intent) => {
+        const primaryScenario = intent.scenarios.find((scenario) => scenario.kind === "primary") ?? intent.scenarios[0];
+        const steps = uniqueStrings([
+            ...(primaryScenario?.steps ?? intent.lifecycle.map((stage) => stage.label)),
+            ...(primaryScenario?.assertions ?? []),
+        ]);
+        return {
+            kind: intentFlowKind(intent, projectType),
+            title: intent.title,
+            reason: `Commit and diff evidence support this ${intent.confidence}-confidence change intent. ${intent.summary}`,
+            files: intent.files,
+            steps,
+            coverage: intent.scenarios.map((scenario) => ({
+                title: scenario.title,
+                priority: scenario.priority,
+                reason: scenario.rationale,
+                checks: uniqueStrings([...scenario.assertions, ...scenario.edgeCases.map((edgeCase) => `Exercise ${lowercaseFirst(edgeCase)}.`)]),
+            })),
+            intentId: intent.id,
+            intentConfidence: intent.confidence,
+            intentEvidence: intent.evidence,
+            lifecycle: intent.lifecycle,
+            qaScenarios: intent.scenarios,
+        };
+    });
+    if (intentCandidates.length === 0) {
+        return heuristicCandidates;
+    }
+    const intentFiles = new Set(intentCandidates.flatMap((candidate) => candidate.files));
+    const nonOverlapping = heuristicCandidates.filter((candidate) => candidate.files.every((file) => !intentFiles.has(file)) || isVerificationOnlyKind(candidate.kind));
+    return [...intentCandidates, ...nonOverlapping].slice(0, 4);
+}
+function intentFlowKind(intent, projectType) {
+    const searchable = `${intent.title} ${intent.keywords.join(" ")} ${intent.lifecycle.map((stage) => stage.label).join(" ")}`.toLowerCase();
+    if (projectType === "cli") {
+        return "command";
+    }
+    if (/\b(?:endpoint|request|response|api|contract)\b/.test(searchable) && projectType === "api-service") {
+        return "api";
+    }
+    if (/\b(?:state|store|persist|sync|toggle|cache|session|notification|reminder)\b/.test(searchable)) {
+        return "state";
+    }
+    if (intent.lifecycle.some((stage) => stage.kind === "observable-outcome") && projectType !== "api-service") {
+        return "ui";
+    }
+    return "domain";
 }
 function cliCommandChecklistTitle(subject) {
     if (/^cli$/i.test(subject.trim())) {
@@ -3387,13 +3587,14 @@ async function buildFlow(root, runner, candidate, testSuiteInventory, fixtureCon
     if (files.length === 0) {
         return undefined;
     }
-    const coverage = buildCoverageTargets(candidate.kind, files, runner);
+    const coverage = candidate.coverage ?? buildCoverageTargets(candidate.kind, files, runner);
     const setupHints = await inferFlowSetupHints(root, files, candidate.kind);
     const interactionEvidenceApplies = !isVerificationOnlyKind(candidate.kind);
     const selectors = interactionEvidenceApplies
         ? await inferFlowSelectors(root, files, runner, addedDiffText)
         : [];
     const flow = {
+        kind: candidate.kind,
         title: candidate.title,
         reason: candidate.reason,
         files,
@@ -3405,6 +3606,11 @@ async function buildFlow(root, runner, candidate, testSuiteInventory, fixtureCon
         fixtureReadiness: await inferFlowFixtureReadiness(root, files, candidate.kind, setupHints, fixtureContext),
         selectors,
         missingTestability: interactionEvidenceApplies ? await findFlowTestabilityGaps(root, files, runner) : [],
+        intentId: candidate.intentId,
+        intentConfidence: candidate.intentConfidence,
+        intentEvidence: candidate.intentEvidence,
+        lifecycle: candidate.lifecycle,
+        qaScenarios: candidate.qaScenarios,
     };
     return {
         ...flow,
@@ -4101,11 +4307,11 @@ function normalizeRouteSegment(segment) {
     if (!stem || /^\([^)]*\)$/.test(stem) || stem.startsWith("_") || stem.startsWith("@")) {
         return undefined;
     }
-    const routeStem = stem.replace(/^\((?:\.{1,3})\)/, "");
+    const routeStem = stem.replace(/^\+/, "").replace(/^\((?:\.{1,3})\)/, "");
     if (!routeStem) {
         return undefined;
     }
-    if (/^(?:index|page|route|layout|template|loading|error|not-found|404|500)$/i.test(routeStem)) {
+    if (/^(?:index|page|route|server|layout|template|loading|error|not-found|404|500)$/i.test(routeStem)) {
         return undefined;
     }
     const dynamic = dynamicRouteSegmentName(routeStem);
@@ -4713,7 +4919,7 @@ async function buildDraftFlows(plan) {
     if (manifestFlows.length === 0 && scenarioFlows.length === 0) {
         return baseFlows.map((flow) => ({
             ...flow,
-            draftSource: "heuristic",
+            draftSource: flow.intentId ? "change-intent" : "heuristic",
         }));
     }
     const combined = prioritizeImportantBaseDraftFlow(dedupeDraftFlowsByOutputPath(dedupeFlows([...manifestFlows, ...scenarioFlows, ...baseFlows]), plan.recommendedRunner.name), baseFlows).slice(0, 4);
@@ -4747,6 +4953,9 @@ function shouldUseDomainScenariosForDraft(plan) {
     if (isLowSignalVerificationOnlyChange(files) || isConfigurationOnlyChange(files)) {
         return false;
     }
+    if (plan.changeAnalysis.intents.some((intent) => intent.confidence !== "low")) {
+        return false;
+    }
     return !plan.flows.every(isEvidenceVerificationFocusedFlow);
 }
 function isEvidenceVerificationFocusedFlow(flow) {
@@ -4805,9 +5014,10 @@ function uniqueManifestCheckMatches(matches) {
 function preferredDraftSource(left, right) {
     const ranks = {
         "verification-manifest": 0,
-        "core-flow": 1,
-        "domain-language": 2,
-        heuristic: 3,
+        "change-intent": 1,
+        "core-flow": 2,
+        "domain-language": 3,
+        heuristic: 4,
     };
     if (!left) {
         return right;
@@ -4822,7 +5032,43 @@ async function buildManifestDraftFlows(plan, baseFlows) {
         .filter((match) => match.kind === "flow")
         .slice(0, 4);
     const checkMatches = plan.verificationManifestMatches.filter((match) => match.kind === "check");
-    return Promise.all(flowMatches.map((match) => buildManifestDraftFlow(plan, match, checkMatches, baseFlows)));
+    const flowDrafts = await Promise.all(flowMatches.map((match) => buildManifestDraftFlow(plan, match, checkMatches, baseFlows)));
+    const flowMatchedFiles = new Set(flowMatches.flatMap((match) => match.matchedFiles));
+    const domainDrafts = await Promise.all(plan.verificationManifestMatches
+        .filter((match) => match.kind === "domain" && match.matchedFiles.some((file) => !flowMatchedFiles.has(file)))
+        .slice(0, 4)
+        .map((match) => buildManifestDomainDraftFlow(plan, match, baseFlows)));
+    return [...flowDrafts, ...domainDrafts.filter((flow) => Boolean(flow))].slice(0, 4);
+}
+async function buildManifestDomainDraftFlow(plan, match, baseFlows) {
+    const manifestFiles = normalizeScenarioFilesForRoot(plan, match.matchedFiles);
+    const baseFlow = bestOverlappingBaseFlowForManifestMatch(manifestFiles, baseFlows);
+    if (!baseFlow || isVerificationOnlyFlow(baseFlow)) {
+        return undefined;
+    }
+    // A domain path can cover many independent flows. Preserve manifest
+    // provenance on the best overlapping flow without claiming every matched
+    // domain file belongs to that single draft.
+    const files = baseFlow.files;
+    const flow = {
+        ...baseFlow,
+        reason: `${match.reason} ${baseFlow.reason}`,
+        files,
+        entrypoints: uniqueEntrypoints([
+            ...baseFlow.entrypoints,
+            ...(await inferFlowEntrypoints(plan.root, files, plan.recommendedRunner.name)),
+        ]),
+        selectors: uniqueSelectors([
+            ...baseFlow.selectors,
+            ...(await inferFlowSelectors(plan.root, files, plan.recommendedRunner.name)),
+        ]),
+        draftSource: "verification-manifest",
+        manifestMatch: match,
+    };
+    return {
+        ...flow,
+        languageBrief: buildFlowLanguageBrief(flow),
+    };
 }
 async function buildManifestDraftFlow(plan, match, checkMatches, baseFlows) {
     const relatedChecks = checkMatches.filter((check) => check.id.startsWith(`${match.id}.`));
@@ -4848,6 +5094,7 @@ async function buildManifestDraftFlow(plan, match, checkMatches, baseFlows) {
         ...(await inferFlowSetupHints(plan.root, files, "domain")),
     ]);
     const flow = {
+        kind: baseFlow?.kind ?? "domain",
         title: match.name,
         reason: match.reason,
         files,
@@ -4879,6 +5126,12 @@ function bestBaseFlowForManifestMatch(files, baseFlows) {
     }
     return best && best.score > 0 ? best.flow : baseFlows[0];
 }
+function bestOverlappingBaseFlowForManifestMatch(files, baseFlows) {
+    const ranked = baseFlows
+        .map((flow) => ({ flow, score: fileOverlapScore(files, flow.files) }))
+        .sort((left, right) => right.score - left.score);
+    return ranked[0]?.score > 0 ? ranked[0].flow : undefined;
+}
 function coreFlowForManifestMatch(plan, match) {
     return plan.coreFlows.find((flow) => flow.name === match.name || flow.id === match.id);
 }
@@ -4978,6 +5231,7 @@ async function buildDomainScenarioDraftFlow(plan, scenario, baseFlows) {
         checks: refinedSteps,
     };
     const flow = {
+        kind: baseFlow?.kind ?? "domain",
         title,
         reason,
         files,
@@ -5159,7 +5413,7 @@ function fileOverlapScore(leftFiles, rightFiles) {
 }
 function draftFlowSource(flow) {
     const draftFlow = flow;
-    return draftFlow.draftSource ?? "heuristic";
+    return draftFlow.draftSource ?? (flow.intentId ? "change-intent" : "heuristic");
 }
 function domainScenarioForFlow(flow) {
     return flow.domainScenario;
@@ -5301,6 +5555,7 @@ function buildFallbackFlow(plan) {
     const fallback = fallbackFlowDefinition(plan.project.type);
     const coverage = buildCoverageTargets(fallback.kind, [], plan.recommendedRunner.name);
     const flow = {
+        kind: fallback.kind,
         title: fallback.title,
         reason: fallback.reason,
         files: [],
@@ -5461,6 +5716,7 @@ function buildMaestroDraft(plan, flow) {
     lines.push(`# Base: ${plan.base}`);
     lines.push(`# Head: ${plan.head}`);
     appendDraftBriefComments(lines, flow, "maestro", "#");
+    appendIntentDraftComments(lines, flow, "#");
     appendExecutionProfileComments(lines, plan.executionProfile, "#");
     appendRunnerSetupProposalComments(lines, plan.runnerSetup, "#");
     lines.push("# Replace ${APP_ID} with the app id or export APP_ID before running Maestro.");
@@ -5551,6 +5807,7 @@ function buildPlaywrightDraft(plan, flow, addedDiffText = {}) {
         lines.push(`// Intent: ${scenario.intent}`);
     }
     appendDraftBriefComments(lines, flow, "playwright", "//");
+    appendIntentDraftComments(lines, flow, "//");
     appendExecutionProfileComments(lines, plan.executionProfile, "//");
     appendRunnerSetupProposalComments(lines, plan.runnerSetup, "//");
     lines.push("");
@@ -5665,6 +5922,7 @@ function buildManualDraft(plan, flow) {
     lines.push(`- Head: \`${plan.head}\``);
     lines.push("");
     appendManualDraftBrief(lines, flow, "manual");
+    appendManualIntentDraft(lines, flow);
     appendManualExecutionProfile(lines, plan.executionProfile);
     appendManualRunnerSetupProposal(lines, plan.runnerSetup);
     lines.push("");
@@ -5983,6 +6241,53 @@ function appendDraftBriefComments(lines, flow, runner, commentPrefix) {
         lines.push(`${commentPrefix}   - ${input}`);
     }
 }
+function appendIntentDraftComments(lines, flow, commentPrefix) {
+    if (!flow.intentId || !flow.lifecycle || !flow.qaScenarios) {
+        return;
+    }
+    lines.push("");
+    lines.push(`${commentPrefix} Change intent evidence:`);
+    lines.push(`${commentPrefix} - Intent id: ${flow.intentId}`);
+    lines.push(`${commentPrefix} - Confidence: ${flow.intentConfidence ?? "low"}`);
+    for (const evidence of (flow.intentEvidence ?? []).filter((item) => item.kind === "commit").slice(0, 5)) {
+        lines.push(`${commentPrefix} - Commit: ${evidence.value}`);
+    }
+    lines.push(`${commentPrefix} - Behavior lifecycle:`);
+    for (const stage of flow.lifecycle.slice(0, 10)) {
+        lines.push(`${commentPrefix}   - ${stage.kind}: ${stage.label}`);
+    }
+    lines.push(`${commentPrefix} - Runner-independent QA scenarios:`);
+    for (const scenario of flow.qaScenarios.slice(0, 4)) {
+        lines.push(`${commentPrefix}   - [${scenario.priority}] ${scenario.kind}: ${scenario.title}`);
+        for (const assertion of scenario.assertions.slice(0, 2)) {
+            lines.push(`${commentPrefix}     - Assert: ${assertion}`);
+        }
+    }
+}
+function appendManualIntentDraft(lines, flow) {
+    if (!flow.intentId || !flow.lifecycle || !flow.qaScenarios) {
+        return;
+    }
+    lines.push("");
+    lines.push("## Change Intent Evidence");
+    lines.push("");
+    lines.push(`- Intent id: \`${flow.intentId}\``);
+    lines.push(`- Confidence: ${flow.intentConfidence ?? "low"}`);
+    for (const evidence of (flow.intentEvidence ?? []).filter((item) => item.kind === "commit").slice(0, 5)) {
+        lines.push(`- Commit: ${evidence.value}`);
+    }
+    lines.push("- Behavior lifecycle:");
+    for (const stage of flow.lifecycle.slice(0, 10)) {
+        lines.push(`  - ${stage.kind}: ${stage.label}`);
+    }
+    lines.push("- Runner-independent QA scenarios:");
+    for (const scenario of flow.qaScenarios.slice(0, 4)) {
+        lines.push(`  - [${scenario.priority}] ${scenario.kind}: ${scenario.title}`);
+        for (const assertion of scenario.assertions.slice(0, 2)) {
+            lines.push(`    - Assert: ${assertion}`);
+        }
+    }
+}
 function appendExecutionProfileComments(lines, profile, commentPrefix) {
     lines.push("");
     lines.push(`${commentPrefix} Execution profile:`);