`qa-suite-summary.json`, and `qa-suite-report.md` artifacts for the selected

scenario set. Scenarios that declare `execution.kind: vitest` or

`execution.kind: playwright` run the matching test path and also write

per-scenario logs. When `qa suite` is reached through

per-scenario logs. Scenarios that declare `execution.kind: script` run the

evidence producer at `execution.path` through `node --import tsx` (with

`${outputDir}` and `${scenarioId}` expanded in `execution.args`); the producer

writes its own `qa-evidence.json`, whose entries are imported into the suite

output and whose artifact paths are resolved relative to that producer

`qa-evidence.json`. When `qa suite` is reached through

`qa run --qa-profile`, the same `qa-evidence.json` also includes the profile

scorecard summary for the selected taxonomy categories.

Treat it as a discovery aid, not a gate replacement; the selected scenario still needs the right provider mode, live transport, Multipass, Testbox, or release lane for the behavior under test.

primary?: readonly string[];

secondary?: readonly string[];

sourcePath?: string;

executionKind?: "flow" | "vitest" | "playwright";

executionKind?: "flow" | "script" | "vitest" | "playwright";

executionPath?: string;

}): QaSeedScenarioWithSource {

const execution =

params.executionKind === "vitest" || params.executionKind === "playwright"

params.executionKind === "script" ||

params.executionKind === "vitest" ||

params.executionKind === "playwright"

? {

kind: params.executionKind,

path: params.executionPath ?? "src/test.test.ts",

]);

});

it("uses script producer evidence as coverage fulfillment", () => {

const report = buildQaScorecardTaxonomyReport({

taxonomy: testMaturityTaxonomy({

categoryId: TEST_BROWSER_CATEGORY_ID,

coverageIds: [TEST_BROWSER_COVERAGE_ID],

}),

repoRoot: process.cwd(),

scenarios: [

scenarioWithCoverage({

primary: [TEST_BROWSER_COVERAGE_ID],

sourcePath: "qa/scenarios/ui/script-evidence-producer.yaml",

executionKind: "script",

executionPath: "scripts/check-no-conflict-markers.mjs",

}),

],

});

expect(report.validationIssues).toStrictEqual([]);

expect(report.fulfilledCategoryCount).toBe(1);

expect(report.fulfilledFeatureCount).toBe(1);

expect(report.categories[0]?.evidence).toStrictEqual([

{

coverageId: TEST_BROWSER_COVERAGE_ID,

kind: "script",

path: "scripts/check-no-conflict-markers.mjs",

role: "primary",

scenarioRefs: ["qa/scenarios/ui/script-evidence-producer.yaml"],

},

]);

});

it("reports profile membership refs missing from taxonomy categories", () => {

const report = buildQaScorecardTaxonomyReport({

taxonomy: testMaturityTaxonomy({

group.push(match);

groups.set(match.executionKind, group);

}

const executionOrder: QaScenarioSearchMatch["executionKind"][] = ["flow", "vitest", "playwright"];

const executionOrder: QaScenarioSearchMatch["executionKind"][] = [

"flow",

"script",

"vitest",

"playwright",

];

return executionOrder.flatMap((executionKind) => {

const group = groups.get(executionKind);

return group && group.length > 0 ? [{ executionKind, matches: group }] : [];

);

}

function resolveQaEvidenceProfile(params: {

export function resolveQaEvidenceProfile(params: {

env?: NodeJS.ProcessEnv;

explicit?: QaEvidenceProfile;

}) {

});

}

export function buildScriptEvidenceSummary(

params: QaEvidenceBuildBase & {

targets: readonly QaEvidenceTestTargetInput[];

results: readonly QaEvidenceTestResultInput[];

},

): QaEvidenceSummaryJson {

return buildTestRunnerEvidenceSummary({

...params,

defaultRunner: "script",

testKind: "script-test",

runner: params.runner ?? "script",

});

}

export function buildLiveTransportEvidenceSummary(

params: QaEvidenceBuildBase & {

checks: readonly QaEvidenceLiveTransportCheckInput[];

const qaTestFileScenarioExecutionSchema = z.discriminatedUnion("kind", [

qaTestFileScenarioExecutionBaseSchema.extend({ kind: z.literal("vitest") }),

qaTestFileScenarioExecutionBaseSchema.extend({ kind: z.literal("playwright") }),

qaTestFileScenarioExecutionBaseSchema.extend({

kind: z.literal("script"),

args: z.array(z.string()).optional(),

}),

]);

const qaScenarioExecutionSchema = z.union([

}

});

export type QaNativeCoverageEvidenceKind = "vitest" | "playwright";

export type QaNativeCoverageEvidenceKind = "script" | "vitest" | "playwright";

export type QaScorecardEvidenceKind = QaNativeCoverageEvidenceKind | "qa-scenario";

export type QaScorecardEvidenceMode = z.infer<typeof qaScorecardEvidenceModeSchema>;

type QaCoverageEvidenceRole = z.infer<typeof qaCoverageEvidenceRoleSchema>;

runQaTestFileScenarios.mockImplementation(

async (params: {

outputDir: string;

scenarios: Array<{ id: string; execution: { kind: "vitest" | "playwright" } }>;

scenarios: Array<{ id: string; execution: { kind: "script" | "vitest" | "playwright" } }>;

}) => {

const [scenario] = params.scenarios;

if (!scenario) {