@planu/cli 4.13.0 → 5.0.0

package/dist/engine/validator/spec-compliance-runner.js

@@ -1,64 +1,55 @@
-// engine/validator/spec-compliance-runner.ts — SPEC-732: vitest-backed spec-compliance runner
-//
-// Replaces the text-matching approach in validateSpec with actual test execution.
-// Parses the `tests` array from each frontmatter scenario, spawns vitest, and
-// produces a per-scenario verdict based on real test outcomes.
-import { access } from 'node:fs/promises';
-import { join } from 'node:path';
+/* eslint-disable max-lines -- runner adapters and exact command evidence stay co-located for auditability */
+import { isAbsolute, join, normalize, relative, sep } from 'node:path';
+import { PROCESS_TERMINATION_GRACE_MS, runAbortableProcess } from '../abortable-process-runner.js';
+import { remainingExecutionMs } from '../execution/context.js';
+import { getRuntimePolicy } from '../runtime-policy.js';
+import { resolveContainedProjectFile } from '../safety/contained-project-file.js';
+import { technologyValue } from '../technology-registry.js';
 import { readMatchingValidationEvidence } from '../validation-evidence-ledger.js';
-import { runAbortableProcess } from '../abortable-process-runner.js';
-// ---------------------------------------------------------------------------
-// Frontmatter scenario parser
-// ---------------------------------------------------------------------------
-/**
- * Parse scenarios from a raw spec.md content string.
- * Handles the multi-line YAML block that the simple KV parser cannot handle.
- *
- * Expected frontmatter shape:
- * ```yaml
- * scenarios:
- *   - title: "Scenario A"
- *     done: false
- *     tests:
- *       - path: tests/foo.test.ts
- *         line: 42
- * ```
- */
-// eslint-disable-next-line complexity, max-lines-per-function -- YAML frontmatter has many structural variants; each branch handles a distinct schema shape (object + string test forms — SPEC-777)
+import { readEvidenceArtifacts, traceabilityRowHasCurrentCommandEvidence, } from '../evidence-gates/artifact-reader.js';
+import { normalizeCriterionText } from '../criterion-identity.js';
+/** A sanitized terminal adapter failure that cannot be mistaken for a failed test verdict. */
+export class ComplianceCommandTerminalError extends Error {
+    code;
+    constructor(code) {
+        super(`[Planu] ${code}`);
+        this.code = code;
+        this.name = 'ComplianceCommandTerminalError';
+    }
+}
+// eslint-disable-next-line complexity, max-lines-per-function -- parses the supported scenario YAML subset without executing it
 export function parseFrontmatterScenarios(raw) {
-    const FRONTMATTER_BLOCK_RE = /^---\n([\s\S]*?)\n---\n/;
-    const match = FRONTMATTER_BLOCK_RE.exec(raw);
+    const match = /^---\n([\s\S]*?)\n---\n/.exec(raw);
     if (!match?.[1]) {
         return [];
     }
-    const block = match[1];
-    const lines = block.split('\n');
     const scenarios = [];
     let inScenarios = false;
     let currentScenario = null;
     let inTests = false;
-    for (const line of lines) {
+    let inSteps = false;
+    let currentStep;
+    for (const line of match[1].split('\n')) {
         const trimmed = line.trimEnd();
-        // Top-level `scenarios:` key
         if (/^scenarios:\s*$/.test(trimmed)) {
             inScenarios = true;
             inTests = false;
+            inSteps = false;
             continue;
         }
-        // Another top-level key — exit scenarios block
         if (inScenarios && /^\S/.test(trimmed) && !trimmed.startsWith('scenarios:')) {
             if (currentScenario) {
                 scenarios.push(currentScenario);
-                currentScenario = null;
             }
+            currentScenario = null;
             inScenarios = false;
             inTests = false;
+            inSteps = false;
             continue;
         }
         if (!inScenarios) {
             continue;
         }
-        // New scenario entry `  - title: ...`
         const titleMatch = /^\s{2}-\s+title:\s*["']?(.+?)["']?\s*$/.exec(trimmed);
         if (titleMatch?.[1]) {
             if (currentScenario) {
@@ -66,53 +57,75 @@ export function parseFrontmatterScenarios(raw) {
             }
             currentScenario = { title: titleMatch[1], done: false };
             inTests = false;
+            inSteps = false;
             continue;
         }
         if (!currentScenario) {
             continue;
         }
-        // `    done: true/false`
         const doneMatch = /^\s+done:\s*(true|false)\s*$/.exec(trimmed);
         if (doneMatch?.[1]) {
             currentScenario.done = doneMatch[1] === 'true';
             continue;
         }
-        // `    tests:` sub-key
         if (/^\s+tests:\s*$/.test(trimmed)) {
-            currentScenario.tests = currentScenario.tests ?? [];
+            currentScenario.tests ??= [];
             inTests = true;
+            inSteps = false;
+            continue;
+        }
+        if (/^\s+steps:\s*$/.test(trimmed)) {
+            currentScenario.steps ??= [];
+            inSteps = true;
+            inTests = false;
+            currentStep = undefined;
             continue;
         }
-        if (inTests) {
-            // Test entry `      - path: ...` (object form)
-            const pathMatch = /^\s+-\s+path:\s*["']?(.+?)["']?\s*$/.exec(trimmed);
-            if (pathMatch?.[1]) {
-                const testLink = { path: pathMatch[1] };
-                currentScenario.tests ??= [];
-                currentScenario.tests.push(testLink);
+        if (inSteps) {
+            const keywordMatch = /^\s+-\s+keyword:\s*["']?(.+?)["']?\s*$/.exec(trimmed);
+            if (keywordMatch?.[1]) {
+                currentStep = { keyword: keywordMatch[1], text: '' };
+                currentScenario.steps ??= [];
+                currentScenario.steps.push(currentStep);
                 continue;
             }
-            // Test entry `      - "tests/foo.test.ts"` or `      - tests/foo.test.ts` (string form)
-            const stringMatch = /^\s+-\s+["']?([^'":\s][^'"]*?)["']?\s*$/.exec(trimmed);
-            if (stringMatch?.[1] && !stringMatch[1].includes(':')) {
-                const testLink = { path: stringMatch[1] };
-                currentScenario.tests ??= [];
-                currentScenario.tests.push(testLink);
+            const textMatch = /^\s+text:\s*["']?(.+?)["']?\s*$/.exec(trimmed);
+            if (textMatch?.[1] && currentStep) {
+                currentStep.text = textMatch[1];
                 continue;
             }
-            // `        line: N` — attach to last test link
-            const lineMatch = /^\s+line:\s*(\d+)\s*$/.exec(trimmed);
-            if (lineMatch?.[1] && currentScenario.tests && currentScenario.tests.length > 0) {
-                const last = currentScenario.tests[currentScenario.tests.length - 1];
-                if (last) {
-                    last.line = parseInt(lineMatch[1], 10);
-                }
-                continue;
+        }
+        if (!inTests) {
+            continue;
+        }
+        const pathMatch = /^\s+-\s+path:\s*["']?(.+?)["']?\s*$/.exec(trimmed);
+        if (pathMatch?.[1]) {
+            currentScenario.tests ??= [];
+            currentScenario.tests.push({ path: pathMatch[1] });
+            continue;
+        }
+        const stringMatch = /^\s+-\s+["']?([^'":\s][^'"]*?)["']?\s*$/.exec(trimmed);
+        if (stringMatch?.[1] && !stringMatch[1].includes(':')) {
+            currentScenario.tests ??= [];
+            currentScenario.tests.push({ path: stringMatch[1] });
+            continue;
+        }
+        const metadataMatch = /^\s+(line|runner|config):\s*["']?(.+?)["']?\s*$/.exec(trimmed);
+        const last = currentScenario.tests?.at(-1);
+        if (metadataMatch?.[1] && metadataMatch[2] && last) {
+            if (metadataMatch[1] === 'line' && /^\d+$/.test(metadataMatch[2])) {
+                last.line = Number.parseInt(metadataMatch[2], 10);
+            }
+            else if (metadataMatch[1] === 'runner') {
+                last.runner = metadataMatch[2];
             }
-            // Another indented key that is not a test entry — exit inTests
-            if (/^\s{4}\S/.test(line)) {
-                inTests = false;
+            else if (metadataMatch[1] === 'config') {
+                last.config = metadataMatch[2];
             }
+            continue;
+        }
+        if (/^\s{4}\S/.test(line)) {
+            inTests = false;
         }
     }
     if (currentScenario) {
@@ -120,197 +133,411 @@ export function parseFrontmatterScenarios(raw) {
     }
     return scenarios;
 }
-/**
- * Spawn vitest with --reporter=json and collect the JSON output.
- * Returns null on timeout or spawn error.
- */
-function runVitest(testPaths, projectPath, timeoutMs = 120_000, signal) {
-    const args = ['exec', 'vitest', '--reporter=json', '--run', ...testPaths];
-    return runAbortableProcess('pnpm', args, {
+function validRelativePath(candidate) {
+    if (candidate.trim() !== candidate ||
+        candidate.length === 0 ||
+        isAbsolute(candidate) ||
+        candidate.includes('\\') ||
+        normalize(candidate) !== candidate) {
+        return false;
+    }
+    return !candidate.split('/').some((segment) => segment === '..' || segment.startsWith('-'));
+}
+async function resolveSafeFile(projectPath, candidate) {
+    if (!validRelativePath(candidate)) {
+        throw new Error('unsafe project-relative path');
+    }
+    const physical = await resolveContainedProjectFile(projectPath, join(projectPath, candidate));
+    const relativePath = relative(projectPath, physical);
+    if (relativePath === '..' || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+        throw new Error('path escapes project');
+    }
+    return physical;
+}
+async function resolveReportedFile(projectPath, candidate) {
+    if (candidate.trim() !== candidate || candidate.length === 0 || candidate.includes('\\')) {
+        throw new Error('unsafe reported path');
+    }
+    const physical = await resolveContainedProjectFile(projectPath, isAbsolute(candidate) ? candidate : join(projectPath, candidate));
+    const pathFromRoot = relative(projectPath, physical);
+    if (pathFromRoot === '..' || pathFromRoot.startsWith(`..${sep}`) || isAbsolute(pathFromRoot)) {
+        throw new Error('reported path escapes project');
+    }
+    return physical;
+}
+async function matchPlaywrightLink(reportedPath, links, projectPath) {
+    if (isAbsolute(reportedPath)) {
+        const physical = await resolveReportedFile(projectPath, reportedPath);
+        const candidates = links.filter((link) => link.physicalPath === physical);
+        return candidates.length === 1 ? (candidates[0] ?? null) : null;
+    }
+    if (!validRelativePath(reportedPath)) {
+        return null;
+    }
+    const candidates = links.filter((link) => link.path === reportedPath || link.path.endsWith(`/${reportedPath}`));
+    return candidates.length === 1 ? (candidates[0] ?? null) : null;
+}
+function parseJsonOutput(stdout) {
+    const jsonStart = stdout.indexOf('{');
+    if (jsonStart === -1) {
+        return null;
+    }
+    try {
+        return JSON.parse(stdout.slice(jsonStart));
+    }
+    catch {
+        return null;
+    }
+}
+function vitestFilePath(result) {
+    for (const candidate of [result.testFilePath, result.name, result.filepath, result.filePath]) {
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function effectiveComplianceTimeoutMs() {
+    const policy = getRuntimePolicy().validation;
+    const availableMs = remainingExecutionMs() - policy.receiptPublicationDeadlineMs - PROCESS_TERMINATION_GRACE_MS;
+    if (availableMs <= 0) {
+        throw new ComplianceCommandTerminalError('COMPLIANCE_COMMAND_DEADLINE_EXHAUSTED');
+    }
+    return Math.min(policy.complianceCommandTimeoutMs, availableMs);
+}
+function throwForTerminalProcessFailure(result) {
+    if (result.aborted) {
+        throw new ComplianceCommandTerminalError('COMPLIANCE_COMMAND_ABORTED');
+    }
+    if (result.timedOut) {
+        throw new ComplianceCommandTerminalError('COMPLIANCE_COMMAND_TIMED_OUT');
+    }
+}
+async function runVitestAdapter(links, projectPath, signal) {
+    const statuses = new Map();
+    const result = await runAbortableProcess('pnpm', [
+        'exec',
+        technologyValue('technology-vitest-a9127f'),
+        '--reporter=json',
+        '--run',
+        ...links.map((link) => link.path),
+    ], {
         cwd: projectPath,
-        timeoutMs,
+        timeoutMs: effectiveComplianceTimeoutMs(),
         maxBufferBytes: 64 * 1024 * 1024,
         signal,
-    }).then((result) => {
-        if (result.status !== 0 || result.error) {
-            return null;
+    });
+    throwForTerminalProcessFailure(result);
+    if (result.error) {
+        return { statuses, detail: 'runner failed' };
+    }
+    const report = parseJsonOutput(result.stdout);
+    if (!report || !Array.isArray(report.testResults)) {
+        return { statuses, detail: 'unparseable runner output' };
+    }
+    for (const testResult of report.testResults) {
+        const reportedPath = vitestFilePath(testResult);
+        if (!reportedPath || !Array.isArray(testResult.assertionResults)) {
+            continue;
+        }
+        const relativePath = isAbsolute(reportedPath)
+            ? relative(projectPath, reportedPath)
+            : reportedPath;
+        if (!links.some((link) => link.path === relativePath)) {
+            continue;
         }
+        const assertions = testResult.assertionResults;
+        statuses.set(relativePath, assertions.length > 0 && assertions.every((item) => item.status === 'passed')
+            ? 'pass'
+            : 'fail');
+    }
+    return { statuses, detail: 'vitest JSON' };
+}
+function collectPlaywrightFiles(suites, output = new Map()) {
+    for (const suite of suites) {
+        if (suite.file) {
+            const statuses = output.get(suite.file) ?? [];
+            for (const spec of suite.specs ?? []) {
+                for (const test of spec.tests ?? []) {
+                    for (const result of test.results ?? []) {
+                        if (typeof result.status === 'string') {
+                            statuses.push(result.status);
+                        }
+                    }
+                }
+            }
+            output.set(suite.file, statuses);
+        }
+        collectPlaywrightFiles(suite.suites ?? [], output);
+    }
+    return output;
+}
+async function runPlaywrightAdapter(links, projectPath, signal) {
+    const statuses = new Map();
+    const config = links[0]?.config;
+    if (!config) {
+        return { statuses, detail: 'missing config' };
+    }
+    const result = await runAbortableProcess('pnpm', [
+        'exec',
+        technologyValue('technology-playwright-7827e8'),
+        'test',
+        '--config',
+        config,
+        '--reporter=json',
+        ...links.map((link) => link.path),
+    ], {
+        cwd: projectPath,
+        timeoutMs: effectiveComplianceTimeoutMs(),
+        maxBufferBytes: 64 * 1024 * 1024,
+        signal,
+    });
+    throwForTerminalProcessFailure(result);
+    if (result.error) {
+        return { statuses, detail: 'runner failed' };
+    }
+    const report = parseJsonOutput(result.stdout);
+    if (!report || !Array.isArray(report.suites)) {
+        return { statuses, detail: 'unparseable runner output' };
+    }
+    const reportedFiles = collectPlaywrightFiles(report.suites);
+    for (const [reportedPath, testStatuses] of reportedFiles) {
         try {
-            const jsonStart = result.stdout.indexOf('{');
-            return jsonStart === -1
-                ? null
-                : JSON.parse(result.stdout.slice(jsonStart));
+            const link = await matchPlaywrightLink(reportedPath, links, projectPath);
+            if (!link) {
+                continue;
+            }
+            statuses.set(link.path, testStatuses.length === 0
+                ? 'missing'
+                : testStatuses.every((status) => status === 'passed')
+                    ? 'pass'
+                    : 'fail');
         }
         catch {
-            return null;
+            // Untrusted reporter paths never become evidence.
         }
-    });
+    }
+    return { statuses, detail: 'playwright JSON' };
 }
-function resolveVitestTestFilePath(result) {
-    // Vitest JSON returns the file path under `testResults[].name` in v4.
-    const candidates = [result.testFilePath, result.name, result.filepath, result.filePath];
-    for (const candidate of candidates) {
-        if (typeof candidate === 'string' && candidate.trim().length > 0) {
-            return candidate;
+async function resolveLink(link, projectPath) {
+    const runner = link.runner ?? technologyValue('technology-vitest-a9127f');
+    const base = {
+        path: link.path,
+        physicalPath: '',
+        runner,
+        ...(link.config ? { config: link.config } : {}),
+    };
+    if (runner !== technologyValue('technology-vitest-a9127f') &&
+        runner !== technologyValue('technology-playwright-7827e8')) {
+        return { ...base, error: `unsupported runner: ${runner}` };
+    }
+    if (runner === technologyValue('technology-vitest-a9127f') && link.config) {
+        return { ...base, error: `${runner} links do not accept config metadata` };
+    }
+    if (runner === technologyValue('technology-playwright-7827e8') && !link.config) {
+        return { ...base, error: `${runner} links require config metadata` };
+    }
+    try {
+        const physicalPath = await resolveSafeFile(projectPath, link.path);
+        if (link.config) {
+            await resolveSafeFile(projectPath, link.config);
         }
+        return { ...base, physicalPath };
     }
-    return null;
+    catch (error) {
+        const message = error.code === 'ENOENT'
+            ? 'file not found'
+            : error instanceof Error
+                ? error.message
+                : 'unsafe or missing path';
+        return { ...base, error: message };
+    }
+}
+function groupKey(link) {
+    return `${link.runner}\0${link.config ?? ''}`;
 }
-function toProjectRelativeTestPath(testFilePath, projectPath) {
-    const prefix = projectPath.endsWith('/') ? projectPath : `${projectPath}/`;
-    return testFilePath.startsWith(prefix) ? testFilePath.slice(prefix.length) : testFilePath;
+const EXECUTABLE_TEST_FILE = /(?:^|\/)[^/]+\.(?:test|spec)\.(?:[cm]?[jt]sx?)$/u;
+function isExecutableTestLink(link) {
+    return link.runner !== undefined || EXECUTABLE_TEST_FILE.test(link.path);
 }
-function resolveScenarioTestPath(link) {
-    return typeof link.path === 'string' && link.path.trim().length > 0 ? link.path : null;
+function normalizedEvidencePath(path) {
+    return path.trim().replaceAll('\\', '/').replace(/^\.\//u, '');
+}
+function commandEvidenceCoversPath(row, path) {
+    return (row?.commandEvidence?.relevantPaths
+        ?.map(normalizedEvidencePath)
+        .includes(normalizedEvidencePath(path)) === true);
+}
+function canonicalScenarioCriterion(scenario) {
+    const steps = scenario.steps ?? [];
+    return steps.length > 0
+        ? steps.map((step) => `${step.keyword.toUpperCase()} ${step.text}`).join(' ')
+        : undefined;
+}
+function resolveExactCommandRow(exactRows, scenario) {
+    const identities = new Set([scenario.title, canonicalScenarioCriterion(scenario)]
+        .filter((value) => typeof value === 'string')
+        .map(normalizeCriterionText)
+        .filter(Boolean));
+    let resolved;
+    for (const identity of identities) {
+        if (!exactRows.has(identity)) {
+            continue;
+        }
+        const candidate = exactRows.get(identity);
+        if (candidate === undefined || (resolved !== undefined && resolved !== candidate)) {
+            return undefined;
+        }
+        resolved = candidate;
+    }
+    return resolved;
+}
+async function loadExactCommandRows(spec, projectPath, canonicalProjectId) {
+    const exactRows = new Map();
+    if (!canonicalProjectId) {
+        return exactRows;
+    }
+    const artifacts = await readEvidenceArtifacts({
+        spec,
+        projectId: canonicalProjectId,
+        specId: spec.id,
+        projectPath,
+    }).catch(() => undefined);
+    for (const row of artifacts?.traceabilityMatrix?.rows ?? []) {
+        if (!traceabilityRowHasCurrentCommandEvidence(row, { projectId: canonicalProjectId, projectPath })) {
+            continue;
+        }
+        const identities = [row.acceptanceCriterion, row.scenario]
+            .filter((value) => typeof value === 'string')
+            .map(normalizeCriterionText)
+            .filter(Boolean);
+        for (const identity of new Set(identities)) {
+            exactRows.set(identity, exactRows.has(identity) && exactRows.get(identity) !== row ? undefined : row);
+        }
+    }
+    return exactRows;
 }
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Run vitest-backed spec-compliance for the given spec.
- * Each frontmatter scenario must have a `tests` array; missing links count as `fail`.
- */
-// eslint-disable-next-line max-lines-per-function, complexity -- spec compliance runner: each section handles a discrete verification phase (file access, scenario parsing, test execution, verdict aggregation)
-export async function runSpecCompliance(spec, projectPath, signal) {
+// eslint-disable-next-line max-lines-per-function -- coordinates validation, adapters, and isolated per-scenario evidence
+export async function runSpecCompliance(spec, projectPath, signal, canonicalProjectId) {
     const { readFile } = await import('node:fs/promises');
     let raw;
     try {
         raw = await readFile(spec.specPath, 'utf-8');
     }
     catch {
-        // No spec file — return empty compliance
         return { dimensionScore: 0, perScenario: [], command: '' };
     }
     const scenarios = parseFrontmatterScenarios(raw);
     if (scenarios.length === 0) {
         return { dimensionScore: 0, perScenario: [], command: '' };
     }
-    // ── Phase 1: collect all unique test paths ────────────────────────────────
-    const allTestPaths = new Set();
-    for (const scenario of scenarios) {
-        for (const link of scenario.tests ?? []) {
-            const linkPath = resolveScenarioTestPath(link);
-            if (linkPath) {
-                allTestPaths.add(linkPath);
-            }
-        }
-    }
-    const command = allTestPaths.size > 0
-        ? `vitest --reporter=json --run ${[...allTestPaths].join(' ')}`
-        : 'vitest --reporter=json --run (no test files linked)';
-    // ── Phase 2: check file existence ────────────────────────────────────────
-    const existenceMap = new Map();
-    for (const p of allTestPaths) {
-        const fullPath = join(projectPath, p);
+    const allLinks = scenarios.flatMap((scenario) => scenario.tests ?? []);
+    const executableLinks = allLinks.filter(isExecutableTestLink);
+    const commandLinks = allLinks.filter((link) => !isExecutableTestLink(link));
+    const resolvedLinks = await Promise.all(executableLinks.map((link) => resolveLink(link, projectPath)));
+    const resolvedBySource = new Map(executableLinks.map((link, index) => [link, resolvedLinks[index]]));
+    const commandLinkErrors = new Map();
+    await Promise.all(commandLinks.map(async (link) => {
         try {
-            await access(fullPath);
-            existenceMap.set(p, true);
+            await resolveSafeFile(projectPath, link.path);
         }
-        catch {
-            existenceMap.set(p, false);
+        catch (error) {
+            commandLinkErrors.set(link, error.code === 'ENOENT'
+                ? 'file not found'
+                : error instanceof Error
+                    ? error.message
+                    : 'unsafe or missing path');
         }
+    }));
+    const exactCommandRows = await loadExactCommandRows(spec, projectPath, canonicalProjectId);
+    const validLinks = resolvedLinks.filter((link) => !link.error);
+    const canonicalLinks = new Map();
+    for (const link of validLinks) {
+        canonicalLinks.set(`${groupKey(link)}\0${link.path}\0${link.physicalPath}`, link);
     }
-    // ── Phase 3: run vitest for existing paths ───────────────────────────────
-    const existingPaths = [...allTestPaths].filter((p) => existenceMap.get(p) === true);
-    let vitestResult = null;
-    const fullTestReceipt = readMatchingValidationEvidence(spec.projectId, {
-        projectPath,
-        capability: 'test-full',
-        command: 'pnpm test',
-        scope: ['src', 'tests'],
-    });
-    if (existingPaths.length > 0 && !fullTestReceipt) {
-        vitestResult = await runVitest(existingPaths, projectPath, 120_000, signal);
+    const groups = new Map();
+    for (const link of canonicalLinks.values()) {
+        groups.set(groupKey(link), [...(groups.get(groupKey(link)) ?? []), link]);
     }
-    // Build a map: testFilePath -> pass/fail
-    const testFileStatus = new Map();
-    if (fullTestReceipt) {
-        for (const path of existingPaths) {
-            testFileStatus.set(path, 'pass');
+    const statusByGroup = new Map();
+    const fullTestReceipt = canonicalProjectId
+        ? readMatchingValidationEvidence(canonicalProjectId, {
+            projectPath,
+            capability: 'test-full',
+            command: 'pnpm test',
+            scope: ['src', 'tests'],
+        })
+        : null;
+    for (const [key, links] of groups) {
+        if (links[0]?.runner === technologyValue('technology-vitest-a9127f') && fullTestReceipt) {
+            statusByGroup.set(key, {
+                statuses: new Map(links.map((link) => [link.path, 'pass'])),
+                detail: 'matching full-test receipt',
+            });
         }
-    }
-    if (vitestResult) {
-        for (const tr of vitestResult.testResults) {
-            const testFilePath = resolveVitestTestFilePath(tr);
-            if (!testFilePath) {
-                continue;
-            }
-            const allPassed = tr.assertionResults.every((r) => r.status === 'passed');
-            testFileStatus.set(testFilePath, allPassed ? 'pass' : 'fail');
-            // Also index by relative path
-            const relPath = toProjectRelativeTestPath(testFilePath, projectPath);
-            testFileStatus.set(relPath, allPassed ? 'pass' : 'fail');
-        }
-    }
-    // ── Phase 4: build per-scenario verdicts ─────────────────────────────────
-    const perScenario = [];
-    let passCount = 0;
-    for (const scenario of scenarios) {
-        const links = scenario.tests ?? [];
-        const evidence = [];
-        let scenarioVerdict;
-        if (links.length === 0) {
-            evidence.push('No test links — scenario has no tests array');
-            scenarioVerdict = 'missing';
+        else if (links[0]?.runner === technologyValue('technology-vitest-a9127f')) {
+            statusByGroup.set(key, await runVitestAdapter(links, projectPath, signal));
         }
         else {
-            // Check all links
-            const verdicts = [];
-            for (const link of links) {
-                const linkPath = resolveScenarioTestPath(link);
-                if (!linkPath) {
-                    evidence.push('Malformed test link: missing path');
-                    verdicts.push('missing');
-                    continue;
-                }
-                const exists = existenceMap.get(linkPath) !== false;
-                if (!exists) {
-                    evidence.push(`${linkPath}: file not found`);
-                    verdicts.push('missing');
-                    continue;
-                }
-                const status = testFileStatus.get(linkPath) ?? (vitestResult || fullTestReceipt ? 'fail' : 'missing');
-                if (status === 'pass') {
-                    evidence.push(`${linkPath}: passed`);
-                    verdicts.push('pass');
-                }
-                else if (status === 'missing') {
-                    evidence.push(`${linkPath}: not found in vitest output`);
-                    verdicts.push('missing');
-                }
-                else {
-                    evidence.push(`${linkPath}: failed`);
-                    verdicts.push('fail');
+            statusByGroup.set(key, await runPlaywrightAdapter(links, projectPath, signal));
+        }
+    }
+    const commands = [...groups.values()].map((links) => {
+        const first = links[0];
+        if (first?.runner === technologyValue('technology-playwright-7827e8')) {
+            return `${first.runner} test --config ${first.config ?? ''} --reporter=json ${links.map((link) => link.path).join(' ')}`;
+        }
+        return `${technologyValue('technology-vitest-a9127f')} --reporter=json --run ${links.map((link) => link.path).join(' ')}`;
+    });
+    const perScenario = scenarios.map((scenario) => {
+        if (!scenario.tests?.length) {
+            return {
+                title: scenario.title,
+                verdict: 'missing',
+                evidence: ['No test links — scenario has no tests array'],
+            };
+        }
+        const evidence = [];
+        const commandRow = resolveExactCommandRow(exactCommandRows, scenario);
+        const verdicts = scenario.tests.map((source) => {
+            if (!isExecutableTestLink(source)) {
+                const error = commandLinkErrors.get(source);
+                if (error) {
+                    evidence.push(`${source.path || '(missing path)'}: ${error}`);
+                    return 'missing';
                 }
+                const verdict = commandEvidenceCoversPath(commandRow, source.path) ? 'pass' : 'missing';
+                evidence.push(`${source.path}: ${verdict === 'pass' ? 'passed by current command evidence' : 'missing current command evidence'}`);
+                return verdict;
             }
-            // Scenario passes only when ALL linked tests pass
-            if (verdicts.every((v) => v === 'pass')) {
-                scenarioVerdict = 'pass';
+            const link = resolvedBySource.get(source);
+            if (!link || link.error) {
+                evidence.push(`${source.path || '(missing path)'}: ${link?.error ?? 'malformed test link'}`);
+                return 'missing';
             }
-            else if (verdicts.some((v) => v === 'missing')) {
-                scenarioVerdict = 'missing';
-            }
-            else {
-                scenarioVerdict = 'fail';
-            }
-        }
-        if (scenarioVerdict === 'pass') {
-            passCount++;
-        }
-        perScenario.push({ title: scenario.title, verdict: scenarioVerdict, evidence });
-    }
-    const dimensionScore = scenarios.length > 0 ? Math.round((passCount / scenarios.length) * 100) : 0;
-    return { dimensionScore, perScenario, command };
+            const adapter = statusByGroup.get(groupKey(link));
+            const verdict = adapter?.statuses.get(link.path) ?? 'missing';
+            evidence.push(`${link.path}: ${verdict === 'pass' ? 'passed' : verdict === 'fail' ? 'failed' : `not found in ${adapter?.detail ?? 'runner output'}`}`);
+            return verdict;
+        });
+        const verdict = verdicts.every((item) => item === 'pass')
+            ? 'pass'
+            : verdicts.some((item) => item === 'missing')
+                ? 'missing'
+                : 'fail';
+        return { title: scenario.title, verdict, evidence };
+    });
+    const passCount = perScenario.filter((scenario) => scenario.verdict === 'pass').length;
+    return {
+        dimensionScore: Math.round((passCount / scenarios.length) * 100),
+        perScenario,
+        command: commands.join(' && ') ||
+            `${technologyValue('technology-vitest-a9127f')} --reporter=json --run (no test files linked)`,
+    };
 }
-// ---------------------------------------------------------------------------
-// check_readiness gate: scenarios_missing_tests
-// ---------------------------------------------------------------------------
-/**
- * Returns a list of scenario titles that lack a `tests` array.
- * Used by check-readiness to block `approved` when scenarios are untested.
- */
 export function findScenariosWithoutTests(raw) {
-    const scenarios = parseFrontmatterScenarios(raw);
-    return scenarios.filter((s) => !s.tests || s.tests.length === 0).map((s) => s.title);
+    return parseFrontmatterScenarios(raw)
+        .filter((scenario) => !scenario.tests?.length)
+        .map((scenario) => scenario.title);
 }
 //# sourceMappingURL=spec-compliance-runner.js.map