agentic-qe 3.14.2 → 3.14.3

package/dist/mcp/handlers/domain-handler-configs.d.ts

@@ -8,7 +8,10 @@
  */
 import { DomainHandlerConfig } from './handler-factory';
 import { TestGenerateParams, TestGenerateResult, TestExecuteParams, CoverageAnalyzeParams, CoverageAnalyzeResult, QualityAssessParams, SecurityScanParams, ContractValidateParams, AccessibilityTestParams, ChaosTestParams } from '../types';
+import type { SecurityScanEvidence } from '../../domains/security-compliance/scan-evidence.js';
+import type { SecurityCoverage } from '../../domains/security-compliance/interfaces.js';
 import { type RiskDecision } from '../../contracts/verdicts.js';
+import type { EvaluatedQualityCheck } from '../../domains/quality-assessment/quality-evidence.js';
 export interface TestExecuteResult {
     taskId: string;
     status: string;
@@ -27,7 +30,10 @@ export interface TestExecuteResult {
 export interface QualityAssessResult {
     taskId: string;
     status: string;
-    qualityScore: number;
+    /** Static analysis score; omitted for measured gates, which have no aggregate score. */
+    qualityScore?: number;
+    /** Canonical measured checks, present when runGate is true. */
+    checks?: EvaluatedQualityCheck[];
     passed: boolean;
     metrics: Record<string, number>;
     recommendations: string[];
@@ -45,9 +51,24 @@ export interface SecurityScanResult {
     medium: number;
     low: number;
     topVulnerabilities: unknown[];
+    findings?: unknown[];
     recommendations: string[];
     duration: number;
     savedFiles?: string[];
+    informational?: number;
+    evidence?: SecurityScanEvidence;
+    limitations?: readonly string[];
+    coverage?: SecurityCoverage;
+    filesScanned?: number;
+    jstsFilesScanned?: number;
+    otherFilesScanned?: number;
+    deepAnalysisPerformed?: boolean;
+    analysisDepth?: string;
+    scanTypes?: {
+        sast: boolean;
+        dast: boolean;
+    };
+    note?: string;
 }
 export interface ContractValidateResult {
     taskId: string;

package/dist/mcp/handlers/domain-handler-configs.js

@@ -406,14 +406,19 @@ export const qualityAssessConfig = {
     priority: 'p0',
     defaultTimeout: 180000,
     buildTaskDescription: (params) => `Assess quality with ${params.runGate ? 'quality gate' : 'metrics analysis'}`,
-    mapToPayload: (params, routingResult) => ({
-        runGate: params.runGate || false,
-        threshold: params.threshold || 80,
-        metrics: params.metrics || ['coverage', 'complexity', 'maintainability'],
-        routingTier: routingResult?.decision.tier,
-        useAgentBooster: routingResult?.useAgentBooster,
-        compiledContext: routingResult?.compiledContext,
-    }),
+    mapToPayload: (params, routingResult) => {
+        if (params.runGate !== undefined && typeof params.runGate !== 'boolean') {
+            throw new Error('runGate must be a boolean.');
+        }
+        return {
+            runGate: params.runGate ?? false,
+            threshold: params.threshold || 80,
+            metrics: params.metrics || ['coverage', 'complexity', 'maintainability'],
+            routingTier: routingResult?.decision.tier,
+            useAgentBooster: routingResult?.useAgentBooster,
+            compiledContext: routingResult?.compiledContext,
+        };
+    },
     mapToResult: (taskId, data, duration, savedFiles) => {
         // ADR-103: attach a schema-validated RiskDecision envelope at the MCP
         // boundary (additive — existing fields unchanged). Omit rather than
@@ -426,7 +431,8 @@ export const qualityAssessConfig = {
         return {
             taskId,
             status: 'completed',
-            qualityScore: data.qualityScore || 0,
+            ...(typeof data.qualityScore === 'number' ? { qualityScore: data.qualityScore } : {}),
+            ...(Array.isArray(data.checks) ? { checks: data.checks } : {}),
             passed: data.passed || false,
             metrics: data.metrics || {},
             recommendations: data.recommendations || [],
@@ -452,25 +458,50 @@ export const securityScanConfig = {
             scanTypes.push('DAST');
         return `Security scan (${scanTypes.join(', ')}) for ${params.target || 'project'}`;
     },
-    mapToPayload: (params, routingResult) => ({
-        sast: params.sast !== false,
-        dast: params.dast || false,
-        compliance: params.compliance || [],
-        target: params.target || '.',
-        routingTier: routingResult?.decision.tier,
-        useAgentBooster: routingResult?.useAgentBooster,
-        compiledContext: routingResult?.compiledContext,
-    }),
+    mapToPayload: (params, routingResult) => {
+        for (const name of ['sast', 'dast']) {
+            if (params[name] !== undefined && typeof params[name] !== 'boolean') {
+                throw new Error(`${name} must be a boolean`);
+            }
+        }
+        return {
+            sast: params.sast !== false,
+            dast: params.dast || false,
+            compliance: params.compliance || [],
+            target: params.target || '.',
+            targetUrl: params.targetUrl,
+            routingTier: routingResult?.decision.tier,
+            useAgentBooster: routingResult?.useAgentBooster,
+            compiledContext: routingResult?.compiledContext,
+        };
+    },
     mapToResult: (taskId, data, duration, savedFiles) => ({
         taskId,
-        status: 'completed',
+        // Legacy task results without receipts cannot establish scan completeness.
+        status: data.evidence?.completeness === 'complete' ? 'completed'
+            : data.evidence?.completeness === 'partial' ? 'partial'
+                : data.evidence ? 'unavailable' : 'unverified',
         vulnerabilities: data.vulnerabilities || 0,
         critical: data.critical || 0,
         high: data.high || 0,
         medium: data.medium || 0,
         low: data.low || 0,
+        informational: data.informational || 0,
         topVulnerabilities: data.topVulnerabilities || [],
+        findings: data.findings,
         recommendations: data.recommendations || [],
+        evidence: data.evidence,
+        limitations: data.limitations || ['Execution receipts unavailable; scan completeness is unverified.'],
+        ...(data.evidence ? {
+            filesScanned: data.filesScanned,
+            jstsFilesScanned: data.jstsFilesScanned,
+            otherFilesScanned: data.otherFilesScanned,
+            coverage: data.coverage,
+        } : {}),
+        deepAnalysisPerformed: Boolean(data.evidence && data.deepAnalysisPerformed === true),
+        analysisDepth: data.analysisDepth,
+        scanTypes: data.scanTypes,
+        note: data.note,
         duration,
         savedFiles,
     }),

package/dist/mcp/handlers/domain-handlers.d.ts

@@ -35,12 +35,13 @@ export declare function resetTaskExecutor(): void;
  */
 export declare const handleTestGenerate: (params: TestGenerateParams) => Promise<ToolResult<TestGenerateResult>>;
 /**
- * Handle test execution tasks
+ * Handle test execution tasks using a nonempty list of concrete file paths.
+ * Expand glob patterns before calling; the task handler rejects them.
  *
  * @example
  * ```typescript
  * const result = await handleTestExecute({
- *   testFiles: ['tests/unit/*.test.ts'],
+ *   testFiles: ['tests/unit/auth.test.ts', 'tests/unit/session.test.ts'],
  *   parallel: true,
  *   parallelism: 4,
  * });
@@ -61,14 +62,15 @@ export declare const handleTestExecute: (params: TestExecuteParams) => Promise<T
  */
 export declare const handleCoverageAnalyze: (params: CoverageAnalyzeParams) => Promise<ToolResult<CoverageAnalyzeResult>>;
 /**
- * Handle quality assessment tasks
+ * Handle quality assessment tasks. With runGate:true, require fresh canonical
+ * evidence and return individual measured checks, without a static aggregate
+ * score. Missing, stale, or malformed evidence returns an error. threshold and
+ * metrics customize analysis-only requests; gate thresholds match the CLI.
  *
  * @example
  * ```typescript
  * const result = await handleQualityAssess({
  *   runGate: true,
- *   threshold: 80,
- *   metrics: ['coverage', 'complexity'],
  * });
  * ```
  */

package/dist/mcp/handlers/domain-handlers.js

@@ -42,12 +42,13 @@ export function resetTaskExecutor() {
  */
 export const handleTestGenerate = createDomainHandler(testGenerateConfig);
 /**
- * Handle test execution tasks
+ * Handle test execution tasks using a nonempty list of concrete file paths.
+ * Expand glob patterns before calling; the task handler rejects them.
  *
  * @example
  * ```typescript
  * const result = await handleTestExecute({
- *   testFiles: ['tests/unit/*.test.ts'],
+ *   testFiles: ['tests/unit/auth.test.ts', 'tests/unit/session.test.ts'],
  *   parallel: true,
  *   parallelism: 4,
  * });
@@ -68,14 +69,15 @@ export const handleTestExecute = createDomainHandler(testExecuteConfig);
  */
 export const handleCoverageAnalyze = createDomainHandler(coverageAnalyzeConfig);
 /**
- * Handle quality assessment tasks
+ * Handle quality assessment tasks. With runGate:true, require fresh canonical
+ * evidence and return individual measured checks, without a static aggregate
+ * score. Missing, stale, or malformed evidence returns an error. threshold and
+ * metrics customize analysis-only requests; gate thresholds match the CLI.
  *
  * @example
  * ```typescript
  * const result = await handleQualityAssess({
  *   runGate: true,
- *   threshold: 80,
- *   metrics: ['coverage', 'complexity'],
  * });
  * ```
  */

package/dist/mcp/protocol-server.js

@@ -434,7 +434,10 @@ export class MCPProtocolServer {
             // the same output, so we can short-circuit repeated calls with an O(1)
             // fingerprint lookup. Tools without isConcurrencySafe (writes, scans,
             // executions) always re-run.
-            const cacheable = tool.definition.isConcurrencySafe === true;
+            // Explicit quality gates depend on current measured evidence and its age,
+            // not just arguments. A cached approval can outlive or contradict evidence.
+            const measuredQualityGate = name === 'quality_assess' && processedCtx.params?.runGate === true;
+            const cacheable = tool.definition.isConcurrencySafe === true && !measuredQualityGate;
             let cacheFingerprint = null;
             if (cacheable && process.env.AQE_SESSION_CACHE !== 'off') {
                 try {
@@ -821,7 +824,7 @@ export class MCPProtocolServer {
                 description: 'Execute test files in parallel with automatic retry on flaky failures. Example: test_execute_parallel({ testFiles: ["tests/auth.test.ts"], parallel: true })',
                 category: 'domain',
                 parameters: [
-                    { name: 'testFiles', type: 'array', description: 'Test files to execute' },
+                    { name: 'testFiles', type: 'array', description: 'Nonempty list of concrete test file paths (relative to the project working directory or absolute). Expand glob patterns before calling; glob patterns are rejected.' },
                     { name: 'parallel', type: 'boolean', description: 'Enable parallel execution', default: true },
                 ],
             },
@@ -849,7 +852,7 @@ export class MCPProtocolServer {
                 category: 'domain',
                 isConcurrencySafe: true,
                 parameters: [
-                    { name: 'runGate', type: 'boolean', description: 'Run quality gate evaluation', default: false },
+                    { name: 'runGate', type: 'boolean', description: 'Evaluate all seven canonical measured quality checks; requires complete, valid evidence from the last 24 hours. Returns individual checks, not a static aggregate score.', default: false },
                 ],
             },
             handler: (params) => handleQualityAssess(params),
@@ -858,12 +861,13 @@ export class MCPProtocolServer {
         this.registerTool({
             definition: {
                 name: 'security_scan_comprehensive',
-                description: 'Run SAST and/or DAST security scans with vulnerability classification. Example: security_scan_comprehensive({ target: "src/", sast: true })',
+                description: 'Run security scans with execution evidence and explicit coverage limitations. Complete means the declared required scope ran, not that all vulnerabilities are absent. Example: security_scan_comprehensive({ target: "src/", sast: true })',
                 category: 'domain',
                 parameters: [
                     { name: 'sast', type: 'boolean', description: 'Run SAST scan', default: true },
                     { name: 'dast', type: 'boolean', description: 'Run DAST scan', default: false },
-                    { name: 'target', type: 'string', description: 'Target to scan' },
+                    { name: 'target', type: 'string', description: 'Source file or directory for SAST' },
+                    { name: 'targetUrl', type: 'string', description: 'URL for a requested DAST scan' },
                 ],
             },
             handler: (params) => handleSecurityScan(params),

package/dist/mcp/types.d.ts

@@ -176,6 +176,9 @@ export interface TestGenerateParams {
  * Test execution parameters
  */
 export interface TestExecuteParams {
+    /** Concrete test file paths for test_execute_parallel; provide a nonempty list.
+     * Expand glob patterns before calling. The task handler does not expand them.
+     */
     testFiles?: string[];
     testSuites?: string[];
     parallel?: boolean;
@@ -211,6 +214,8 @@ export interface SecurityScanParams {
     dast?: boolean;
     compliance?: string[];
     target?: string;
+    /** URL for explicitly requested dynamic scanning. */
+    targetUrl?: string;
 }
 /**
  * Contract validation parameters

package/dist/shared/llm/router/hybrid-router.d.ts

@@ -113,6 +113,8 @@ export declare class HybridRouter {
      * Clear decision cache
      */
     clearCache(): void;
+    /** Select an explicitly pinned model without rules, shared cache, or fallback. */
+    private selectStrict;
     /**
      * Manual selection - use preferredProvider or default
      */
@@ -133,6 +135,8 @@ export declare class HybridRouter {
      * Execute request with fallback chain
      */
     private executeWithFallback;
+    /** Compare identity independently of the API transport hosting the model. */
+    private isSameModel;
     /**
      * Create a routing decision with proper model ID normalization (ADR-043)
      */

package/dist/shared/llm/router/hybrid-router.js

@@ -139,8 +139,11 @@ export class HybridRouter {
     async selectProvider(params) {
         await this.ensureInitialized();
         const startTime = Date.now();
+        // Strict requests carry their own execution identity. They must neither
+        // consume an ordinary cached decision nor replace one used by other callers.
+        const cacheDecision = this.config.cacheDecisions && !params.strictModel;
         // Check cache first
-        if (this.config.cacheDecisions) {
+        if (cacheDecision) {
             const cacheKey = this.generateCacheKey(params);
             const cached = this.decisionCache.get(cacheKey);
             if (cached) {
@@ -152,26 +155,31 @@ export class HybridRouter {
             this.routerMetrics.recordCacheMiss();
         }
         let decision;
-        switch (this.config.mode) {
-            case 'manual':
-                decision = await this.selectManual(params);
-                break;
-            case 'rule-based':
-                decision = await this.selectRuleBased(params);
-                break;
-            case 'cost-optimized':
-                decision = await this.selectCostOptimized(params);
-                break;
-            case 'performance-optimized':
-                decision = await this.selectPerformanceOptimized(params);
-                break;
-            default:
-                decision = await this.selectRuleBased(params);
+        if (params.strictModel) {
+            decision = this.selectStrict(params);
+        }
+        else {
+            switch (this.config.mode) {
+                case 'manual':
+                    decision = await this.selectManual(params);
+                    break;
+                case 'rule-based':
+                    decision = await this.selectRuleBased(params);
+                    break;
+                case 'cost-optimized':
+                    decision = await this.selectCostOptimized(params);
+                    break;
+                case 'performance-optimized':
+                    decision = await this.selectPerformanceOptimized(params);
+                    break;
+                default:
+                    decision = await this.selectRuleBased(params);
+            }
         }
         // Update decision time
         decision.metadata.decisionTimeMs = Date.now() - startTime;
         // Cache the decision
-        if (this.config.cacheDecisions) {
+        if (cacheDecision) {
             const cacheKey = this.generateCacheKey(params);
             this.decisionCache.set(cacheKey, decision);
         }
@@ -194,6 +202,9 @@ export class HybridRouter {
         // applies the same pin independently for advisor escalations.
         const agentName = params.agentType ?? '';
         if (shouldCyberPin(agentName) && (isOpus47(decision.model) || isOpus47(decision.providerModelId))) {
+            if (params.strictModel) {
+                throw createLLMError(`Strict model request for ${decision.model} conflicts with the cyber verification pin for ${agentName}`, 'MODEL_NOT_FOUND', { provider: decision.providerType, model: decision.model, retryable: false });
+            }
             const originalModel = decision.model;
             const originalProviderModelId = decision.providerModelId;
             decision.model = applyCyberPin(agentName, decision.model, CYBER_PIN_CHAT_FALLBACK);
@@ -313,6 +324,18 @@ export class HybridRouter {
     // ============================================================================
     // Provider Selection Methods
     // ============================================================================
+    /** Select an explicitly pinned model without rules, shared cache, or fallback. */
+    selectStrict(params) {
+        if (!params.model?.trim()) {
+            throw createLLMError('strictModel requires an explicit nonempty model', 'MODEL_NOT_FOUND', { retryable: false });
+        }
+        const providerType = (params.preferredProvider ?? this.config.defaultProvider);
+        const provider = this.providerManager.getProvider(providerType);
+        if (!provider) {
+            throw createLLMError(`Strict model provider ${providerType} is unavailable`, 'PROVIDER_UNAVAILABLE', { provider: providerType, model: params.model, retryable: false });
+        }
+        return this.createDecision(provider, providerType, params.model, 'manual');
+    }
     /**
      * Manual selection - use preferredProvider or default
      */
@@ -452,7 +475,7 @@ export class HybridRouter {
         // surfaced by the rule-based E2E test in
         // tests/e2e/llm-router-real-providers.test.ts.
         const defaultProviderType = this.config.defaultProvider;
-        if (defaultProviderType && defaultProviderType !== decision.providerType) {
+        if (!params.strictModel && defaultProviderType && defaultProviderType !== decision.providerType) {
             executionOrder.push({
                 provider: defaultProviderType,
                 model: this.config.defaultModel,
@@ -464,13 +487,15 @@ export class HybridRouter {
         // openrouter/gemini/azure-openai/bedrock from ADR-043) and
         // ProviderManager.createProvider() builds all of them. The narrower
         // list silently excluded users' actual fallback providers.
-        for (const entry of fallbackChain.entries) {
-            if (!entry.enabled)
-                continue;
-            if (entry.provider === decision.providerType)
-                continue;
-            for (const model of entry.models) {
-                executionOrder.push({ provider: entry.provider, model });
+        if (!params.strictModel) {
+            for (const entry of fallbackChain.entries) {
+                if (!entry.enabled)
+                    continue;
+                if (entry.provider === decision.providerType)
+                    continue;
+                for (const model of entry.models) {
+                    executionOrder.push({ provider: entry.provider, model });
+                }
             }
         }
         // Capability-aware guard: when the request needs tools, drop any candidate
@@ -520,6 +545,17 @@ export class HybridRouter {
                 // ADR-123: persist the charge to the cross-process ledger so budgets
                 // hold across a fleet of processes. ADR-124 M2.3: attribute to the agent.
                 this.providerManager.recordResponseSpend(response, params.agentType);
+                // A provider can return an unexpected model even when its request was
+                // pinned. Account for the completed call, but do not accept that answer
+                // as evidence from the requested model (e.g. a frontier quality judge).
+                if (params.strictModel) {
+                    if (response.provider !== providerType) {
+                        throw createLLMError(`Strict model provider mismatch: expected ${providerType}, received ${response.provider}`, 'PROVIDER_UNAVAILABLE', { provider: providerType, model, retryable: false });
+                    }
+                    if (!this.isSameModel(decision.model, response.model)) {
+                        throw createLLMError(`Strict model mismatch: expected ${decision.model}, received ${response.model}`, 'MODEL_NOT_FOUND', { provider: providerType, model, retryable: false });
+                    }
+                }
                 const callLatency = Date.now() - callStartTime;
                 // Record success in legacy tracker
                 this.metrics.recordSuccess(providerType);
@@ -585,7 +621,7 @@ export class HybridRouter {
                 // delay (because no need to wait) but DOES continue to the next
                 // entry in executionOrder. Only retryable errors get the delay.
                 const nonRetryable = isLLMError(error) && !error.retryable;
-                if (!nonRetryable && attempts < fallbackBehavior.maxAttempts) {
+                if (!params.strictModel && !nonRetryable && attempts < fallbackBehavior.maxAttempts) {
                     await this.delay(fallbackBehavior.delayMs);
                 }
             }
@@ -595,6 +631,18 @@ export class HybridRouter {
     // ============================================================================
     // Helper Methods
     // ============================================================================
+    /** Compare identity independently of the API transport hosting the model. */
+    isSameModel(expected, actual) {
+        if (expected === actual)
+            return true;
+        try {
+            return normalizeModelId(expected) === normalizeModelId(actual);
+        }
+        catch {
+            // Unregistered model IDs are only equivalent when they match exactly.
+            return false;
+        }
+    }
     /**
      * Create a routing decision with proper model ID normalization (ADR-043)
      */

package/dist/shared/llm/router/types.d.ts

@@ -686,9 +686,16 @@ export interface ChatParams {
     agentType?: string;
     /** Task complexity hint */
     complexity?: TaskComplexity;
-    /** Specific model to use (for manual mode) - canonical or provider-specific ID */
+    /** Specific model to use (for manual mode or strictModel) - canonical or provider-specific ID */
     model?: string;
-    /** Preferred provider (for manual mode) - supports extended providers */
+    /**
+     * Require the explicit model on preferredProvider (or the configured default).
+     * Bypasses routing rules and decision caching, disallows provider/model
+     * fallback, and rejects responses from a different provider or model.
+     * Equivalent canonical and provider-specific model IDs are accepted.
+     */
+    strictModel?: boolean;
+    /** Preferred provider (for manual mode or strictModel) - supports extended providers */
     preferredProvider?: ExtendedProviderType;
     /** Required capabilities (legacy) */
     requiredCapabilities?: string[];

package/dist/shared/test-runner-verdict.d.ts

@@ -0,0 +1,29 @@
+/** A runner or suite error is not an assertion result. */
+export declare class TestRunnerExecutionError extends Error {
+    constructor(message: string);
+}
+interface RunnerCounts {
+    passed: number;
+    failed: number;
+    skipped: number;
+}
+interface RunnerReport {
+    success?: boolean;
+    numFailedTestSuites?: number;
+    numRuntimeErrorTestSuites?: number;
+    testResults?: Array<{
+        status?: string;
+        message?: string;
+        assertionResults?: Array<{
+            status?: string;
+        }>;
+    }>;
+}
+/**
+ * Preserve ordinary assertion failures, but reject incomplete/failed execution
+ * that assertion counts cannot represent. Process status is authoritative even
+ * when a runner emits success=true (for example, Vitest unhandled rejections).
+ */
+export declare function getTestRunnerExecutionError(runner: string, files: string, exitCode: number | null, counts: RunnerCounts, output: string, report?: RunnerReport): TestRunnerExecutionError | undefined;
+export {};
+//# sourceMappingURL=test-runner-verdict.d.ts.map

package/dist/shared/test-runner-verdict.js

@@ -0,0 +1,43 @@
+/** A runner or suite error is not an assertion result. */
+export class TestRunnerExecutionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TestRunnerExecutionError';
+    }
+}
+/**
+ * Preserve ordinary assertion failures, but reject incomplete/failed execution
+ * that assertion counts cannot represent. Process status is authoritative even
+ * when a runner emits success=true (for example, Vitest unhandled rejections).
+ */
+export function getTestRunnerExecutionError(runner, files, exitCode, counts, output, report) {
+    const suites = report?.testResults ?? [];
+    const suiteErrors = suites.filter(suite => suite.status === 'failed' && (
+    // Jest also uses message for ordinary assertion failures; Vitest reserves
+    // it for suite errors such as collection and afterAll failures.
+    (runner === 'vitest' && suite.message)
+        || !suite.assertionResults?.some(assertion => assertion.status === 'failed')));
+    let reason;
+    if (exitCode === null) {
+        reason = 'terminated without an exit code';
+    }
+    else if (counts.passed + counts.failed + counts.skipped === 0) {
+        reason = 'reported zero tests';
+    }
+    else if (suiteErrors.length > 0 || (report?.numRuntimeErrorTestSuites ?? 0) > 0
+        || ((report?.numFailedTestSuites ?? 0) > 0 && counts.failed === 0)) {
+        reason = 'reported a suite execution error';
+    }
+    else if ((exitCode !== 0 || report?.success === false) && counts.failed === 0) {
+        reason = 'failed without a failed assertion';
+    }
+    if (!reason)
+        return undefined;
+    const diagnostics = [
+        ...suiteErrors.map(suite => suite.message).filter(Boolean),
+        output.trim(),
+    ].filter(Boolean).join('\n').slice(0, 4000);
+    return new TestRunnerExecutionError(`${runner} ${reason} for ${files} (exit code ${exitCode ?? 'unknown'}).` +
+        (diagnostics ? `\n${diagnostics}` : ''));
+}
+//# sourceMappingURL=test-runner-verdict.js.map

package/dist/shared/vitest-json-report.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Vitest JSON report handling that works on Vitest 4 and 5.
+ *
+ * Vitest 5 no longer prints the `--reporter=json` document to stdout; it
+ * writes `.vitest/json/output.json` and prints only
+ * `JSON report written to <path>`. Vitest 4 prints the document to stdout
+ * unless `--outputFile` is given, in which case it behaves like Vitest 5.
+ *
+ * Passing an explicit `--outputFile` therefore gives one contract on both
+ * majors: the report is always in a file we own. Every runner integration
+ * that spawns `vitest run --reporter=json` must go through this module
+ * instead of parsing stdout directly.
+ */
+export interface VitestJsonReport {
+    /** Absolute path the report will be written to. */
+    readonly path: string;
+    /** CLI arguments to append to `vitest run --reporter=json`. */
+    readonly args: readonly string[];
+    /**
+     * Return the text that carries the JSON document: the report file when the
+     * runner wrote one, otherwise the captured stdout (older runners, or a run
+     * that died before reporting).
+     */
+    read(stdout: string): string;
+    /** Remove the temporary report directory. Safe to call more than once. */
+    cleanup(): void;
+}
+/**
+ * Resolve the JSON document text for a finished Vitest run.
+ * Exported separately so the precedence rule is unit-testable without spawning.
+ */
+export declare function resolveVitestJsonOutput(stdout: string, reportPath: string | undefined): string;
+/**
+ * Create a per-run report location. The directory is unique per call so
+ * concurrent runs never read each other's output.
+ */
+export declare function createVitestJsonReport(): VitestJsonReport;
+/**
+ * True when a command vector (runner command plus arguments) is a
+ * `vitest ... --reporter=json` invocation that has not already been given an
+ * output file. Pass the runner command as the first element when the caller
+ * configures it separately (for example `testRunner: 'vitest'`).
+ */
+export declare function needsVitestJsonReportFile(args: readonly string[]): boolean;
+//# sourceMappingURL=vitest-json-report.d.ts.map