agent-scenario-loop 0.1.2 → 0.1.4

package/dist/core/comparison.d.ts

@@ -11,7 +11,7 @@ type MetricComparison = {
     baseline: number | boolean | null;
     current: number | boolean | null;
     delta: number | null;
-    status: 'better' | 'worse' | 'unchanged' | 'inconclusive';
+    status: 'better' | 'worse' | 'unchanged' | 'inconclusive' | 'low_confidence';
     notes?: string;
 };
 type ComparisonStatus = MetricComparison['status'] | 'mixed';
@@ -25,12 +25,18 @@ type ComparisonRunBasis = {
 type ComparisonSelectionBasis = {
     artifactRoot?: string;
     candidatesInspected?: number;
+    cohortHash?: string;
+    comparisonLane?: string;
     scenarioId?: string;
+    scenarioHash?: string;
     selectedRunDir?: string;
     selectedRunId?: string;
     skippedCurrentRun?: boolean;
+    trustedCohortCandidates?: number;
+    trustedComparableCandidates?: number;
     trustedCandidates?: number;
     trustedPriorCandidates?: number;
+    trustedScenarioContractCandidates?: number;
 };
 type ComparisonBasis = {
     baseline: ComparisonRunBasis;
@@ -38,6 +44,42 @@ type ComparisonBasis = {
     selection?: ComparisonSelectionBasis;
     strategy: ComparisonBasisStrategy;
 };
+type MeasurementPolicy = {
+    baselineSelection: {
+        mode: 'explicit' | 'latestTrustedPrior';
+        poisoningProtection: {
+            requirePassedHealth: boolean;
+            requirePassedVerdict: boolean;
+            requireMatchingScenarioId: boolean;
+            comparisonLane?: string;
+            scenarioHash?: string;
+            cohortHash?: string;
+        };
+    };
+    samples: {
+        baseline: {
+            validSamples: number;
+            warmupSamples: number;
+            outliersExcluded: number;
+        };
+        current: {
+            validSamples: number;
+            warmupSamples: number;
+            outliersExcluded: number;
+        };
+    };
+    tolerance: {
+        timing: {
+            absoluteMs: number;
+            relative: number;
+        };
+    };
+    confidence: {
+        level: 'single_run' | 'multi_sample' | 'insufficient' | 'low_confidence';
+        minValidSamples: number;
+        reason?: string;
+    };
+};
 type BuildComparisonOptions = {
     baselineHealth: ComparisonRecord;
     baselineVerdict: ComparisonRecord;
@@ -103,6 +145,18 @@ declare function buildComparisonBasis({ baselineDir, currentDir, baselineHealth,
     selection?: ComparisonSelectionBasis;
     strategy: ComparisonBasisStrategy;
 }): ComparisonBasis;
+/**
+ * Builds the measurement policy block for a comparison artifact.
+ *
+ * @param {{baselineVerdict: Record<string, unknown>, comparisonBasis?: ComparisonBasis, currentVerdict: Record<string, unknown>, metricComparisons: MetricComparison[]}} options
+ * @returns {MeasurementPolicy}
+ */
+declare function buildMeasurementPolicy({ baselineVerdict, comparisonBasis, currentVerdict, metricComparisons, }: {
+    baselineVerdict: ComparisonRecord;
+    comparisonBasis: ComparisonBasis | undefined;
+    currentVerdict: ComparisonRecord;
+    metricComparisons: MetricComparison[];
+}): MeasurementPolicy;
 /**
  * Builds a comparison artifact from two validated run artifact sets.
  *
@@ -129,5 +183,5 @@ declare function summarizeComparison({ comparisonStatus, missingRequired, metric
     metricComparisons: MetricComparison[];
     warnings: string[];
 }): string;
-export { buildComparisonBasis, buildComparisonArtifact, compareBudgetCheck, compareRunDirectories, indexBudgetChecks, readRunArtifacts, resolveComparisonStatus, summarizeComparison, };
-export type { BuildComparisonOptions, ComparisonBasis, ComparisonBasisStrategy, CompareRunDirectoriesOptions, ComparisonBudgetCheck, ComparisonRecord, ComparisonStatus, MetricComparison, };
+export { buildComparisonBasis, buildComparisonArtifact, compareBudgetCheck, compareRunDirectories, buildMeasurementPolicy, indexBudgetChecks, readRunArtifacts, resolveComparisonStatus, summarizeComparison, };
+export type { BuildComparisonOptions, ComparisonBasis, ComparisonBasisStrategy, CompareRunDirectoriesOptions, ComparisonBudgetCheck, ComparisonRecord, ComparisonStatus, MeasurementPolicy, MetricComparison, };

package/dist/core/comparison.js

@@ -4,6 +4,7 @@ exports.buildComparisonBasis = buildComparisonBasis;
 exports.buildComparisonArtifact = buildComparisonArtifact;
 exports.compareBudgetCheck = compareBudgetCheck;
 exports.compareRunDirectories = compareRunDirectories;
+exports.buildMeasurementPolicy = buildMeasurementPolicy;
 exports.indexBudgetChecks = indexBudgetChecks;
 exports.readRunArtifacts = readRunArtifacts;
 exports.resolveComparisonStatus = resolveComparisonStatus;
@@ -113,6 +114,21 @@ function compareBudgetCheck(baseline, current) {
             : {}),
     };
 }
+/**
+ * Returns whether a directional timing delta should be reported as low confidence.
+ *
+ * @param {MetricComparison} metric
+ * @param {ComparisonBudgetCheck} baseline
+ * @param {ComparisonBudgetCheck} current
+ * @returns {boolean}
+ */
+function isLowConfidenceTimingMovement(metric, baseline, current) {
+    return (metric.status === 'worse' &&
+        baseline.unit === 'ms' &&
+        current.unit === 'ms' &&
+        baseline.pass === true &&
+        current.pass === true);
+}
 /**
  * Collapses metric-level comparison statuses into the run-level comparison status.
  *
@@ -123,6 +139,7 @@ function compareBudgetCheck(baseline, current) {
 function resolveComparisonStatus(metricComparisons, { baselineVerdictStatus, currentVerdictStatus, }) {
     const hasBetterMetric = metricComparisons.some((metric) => metric.status === 'better');
     const hasWorseMetric = metricComparisons.some((metric) => metric.status === 'worse');
+    const hasLowConfidenceMetric = metricComparisons.some((metric) => metric.status === 'low_confidence');
     if (hasBetterMetric && hasWorseMetric) {
         return 'mixed';
     }
@@ -132,6 +149,9 @@ function resolveComparisonStatus(metricComparisons, { baselineVerdictStatus, cur
     if (hasBetterMetric) {
         return 'better';
     }
+    if (hasLowConfidenceMetric) {
+        return 'low_confidence';
+    }
     if (metricComparisons.length > 0 && metricComparisons.every((metric) => metric.status === 'unchanged')) {
         return 'unchanged';
     }
@@ -169,6 +189,79 @@ function buildComparisonBasis({ baselineDir, currentDir, baselineHealth, baselin
         ...(selection ? { selection } : {}),
     };
 }
+/**
+ * Counts valid numeric or boolean budget samples in a verdict artifact.
+ *
+ * @param {unknown} checks
+ * @returns {number}
+ */
+function countValidBudgetSamples(checks) {
+    if (!Array.isArray(checks)) {
+        return 0;
+    }
+    return checks.filter((check) => (check &&
+        typeof check === 'object' &&
+        (typeof check.actual === 'number' ||
+            typeof check.actual === 'boolean'))).length;
+}
+/**
+ * Builds the measurement policy block for a comparison artifact.
+ *
+ * @param {{baselineVerdict: Record<string, unknown>, comparisonBasis?: ComparisonBasis, currentVerdict: Record<string, unknown>, metricComparisons: MetricComparison[]}} options
+ * @returns {MeasurementPolicy}
+ */
+function buildMeasurementPolicy({ baselineVerdict, comparisonBasis, currentVerdict, metricComparisons, }) {
+    const selection = comparisonBasis?.selection;
+    const validSamples = metricComparisons.length;
+    const hasLowConfidenceMovement = metricComparisons.some((metric) => metric.status === 'low_confidence');
+    const confidenceLevel = hasLowConfidenceMovement
+        ? 'low_confidence'
+        :
+            validSamples === 0
+                ? 'insufficient'
+                : validSamples === 1
+                    ? 'single_run'
+                    : 'multi_sample';
+    const poisoningProtection = {
+        requirePassedHealth: true,
+        requirePassedVerdict: comparisonBasis?.strategy === 'latest_trusted_prior',
+        requireMatchingScenarioId: true,
+        ...(typeof selection?.comparisonLane === 'string' ? { comparisonLane: selection.comparisonLane } : {}),
+        ...(typeof selection?.scenarioHash === 'string' ? { scenarioHash: selection.scenarioHash } : {}),
+        ...(typeof selection?.cohortHash === 'string' ? { cohortHash: selection.cohortHash } : {}),
+    };
+    return {
+        baselineSelection: {
+            mode: comparisonBasis?.strategy === 'latest_trusted_prior' ? 'latestTrustedPrior' : 'explicit',
+            poisoningProtection,
+        },
+        samples: {
+            baseline: {
+                validSamples: countValidBudgetSamples(baselineVerdict.budgetChecks),
+                warmupSamples: 0,
+                outliersExcluded: 0,
+            },
+            current: {
+                validSamples: countValidBudgetSamples(currentVerdict.budgetChecks),
+                warmupSamples: 0,
+                outliersExcluded: 0,
+            },
+        },
+        tolerance: {
+            timing: {
+                absoluteMs: MIN_MS_COMPARISON_TOLERANCE,
+                relative: RELATIVE_MS_COMPARISON_TOLERANCE,
+            },
+        },
+        confidence: {
+            level: confidenceLevel,
+            minValidSamples: 1,
+            ...(hasLowConfidenceMovement
+                ? { reason: 'Single-run timing movement stayed within passing budgets; repeat or multi-sample proof is required before treating it as a regression.' }
+                : {}),
+        },
+    };
+}
 /**
  * Builds a comparison artifact from two validated run artifact sets.
  *
@@ -202,7 +295,17 @@ function buildComparisonArtifact({ baselineHealth, baselineVerdict, comparisonBa
                 warnings.push(`No baseline budget check matched ${currentCheck.name}.`);
                 continue;
             }
-            metricComparisons.push(compareBudgetCheck(baselineCheck, currentCheck));
+            const metricComparison = compareBudgetCheck(baselineCheck, currentCheck);
+            if (comparisonBasis?.strategy === 'latest_trusted_prior' &&
+                isLowConfidenceTimingMovement(metricComparison, baselineCheck, currentCheck)) {
+                metricComparisons.push({
+                    ...metricComparison,
+                    status: 'low_confidence',
+                    notes: 'Single-run timing movement stayed within passing budgets; repeat or multi-sample proof is required before treating it as a regression.',
+                });
+                continue;
+            }
+            metricComparisons.push(metricComparison);
         }
         if (metricComparisons.length === 0) {
             warnings.push('No comparable budget checks were available.');
@@ -228,6 +331,12 @@ function buildComparisonArtifact({ baselineHealth, baselineVerdict, comparisonBa
         healthStatus: canCompare ? 'passed' : 'failed',
         verdictStatus: typeof currentVerdict.verdictStatus === 'string' ? currentVerdict.verdictStatus : 'inconclusive',
         ...(comparisonBasis ? { comparisonBasis } : {}),
+        measurementPolicy: buildMeasurementPolicy({
+            baselineVerdict,
+            comparisonBasis,
+            currentVerdict,
+            metricComparisons,
+        }),
         ...(metricComparisons.length > 0 ? { metricComparisons } : {}),
         evidence: {
             missingRequired,
@@ -287,6 +396,9 @@ function summarizeComparison({ comparisonStatus, missingRequired, metricComparis
     if (comparisonStatus === 'mixed') {
         return 'Current run has mixed metric movement against the explicit baseline.';
     }
+    if (comparisonStatus === 'low_confidence') {
+        return 'Current run has low-confidence timing movement against the baseline; repeat or multi-sample proof is required before treating it as a regression.';
+    }
     if (comparisonStatus === 'unchanged') {
         return 'Current run matched the explicit baseline.';
     }

package/dist/core/planner.d.ts

@@ -8,10 +8,18 @@ type CompatibilityResult = {
     compatible: boolean;
     errors: PlannerIssue[];
     warnings: PlannerIssue[];
+    downgradePolicy: {
+        mode: string;
+        allowedSubstitutions: Array<Record<string, unknown>>;
+        substitutions: Array<Record<string, unknown>>;
+        unsupported: Array<Record<string, unknown>>;
+        warnings: Array<Record<string, unknown>>;
+    };
     matched: {
         platforms: string[];
         capabilities: string[];
         driverActions: string[];
+        uiContexts: string[];
         artifacts: string[];
         evidenceProviders: string[];
     };
@@ -22,6 +30,7 @@ type ScenarioStep = ManifestRecord & {
     id?: unknown;
     required?: unknown;
     selector?: unknown;
+    uiContext?: unknown;
 };
 type ScenarioManifest = ManifestRecord & {
     adapterOptions?: unknown;
@@ -44,6 +53,7 @@ type RunnerManifest = ManifestRecord & {
     platforms?: unknown[];
     capabilities?: unknown[];
     driverActions?: unknown[];
+    uiContexts?: unknown[];
     artifactOutputs?: unknown[];
 };
 /**
@@ -72,6 +82,27 @@ declare function collectProvidedDriverActions({ runner, evidenceProviders, effec
     evidenceProviders: RunnerManifest[];
     effectivePlatforms: string[];
 }): string[];
+/**
+ * Collects UI/system contexts owned by the primary runner and active providers.
+ *
+ * @param {{runner: Record<string, unknown>, evidenceProviders: Record<string, unknown>[], effectivePlatforms: string[]}} options
+ * @returns {string[]}
+ */
+declare function collectProvidedUiContexts({ runner, evidenceProviders, effectivePlatforms, }: {
+    runner: RunnerManifest;
+    evidenceProviders: RunnerManifest[];
+    effectivePlatforms: string[];
+}): string[];
+/**
+ * Collects UI/system contexts required by scenario steps.
+ *
+ * @param {Record<string, unknown>} scenario
+ * @returns {{required: string[], optional: string[]}}
+ */
+declare function collectScenarioUiContexts(scenario: ScenarioManifest): {
+    required: string[];
+    optional: string[];
+};
 /**
  * Collects driver operations required by scenario steps.
  *
@@ -128,5 +159,5 @@ declare function buildUnevaluatedVerdict({ scenario, runId, health, }: {
     runId?: string;
     health: ManifestRecord;
 }): ManifestRecord;
-export { buildCompatibilityHealth, buildUnevaluatedVerdict, collectProvidedDriverActions, collectScenarioDriverActions, evaluateRunnerCompatibility, intersection, uniqueSorted, validateScenarioAdapterOptions, };
+export { buildCompatibilityHealth, buildUnevaluatedVerdict, collectProvidedDriverActions, collectProvidedUiContexts, collectScenarioDriverActions, collectScenarioUiContexts, evaluateRunnerCompatibility, intersection, uniqueSorted, validateScenarioAdapterOptions, };
 export type { CompatibilityResult, ManifestRecord, PlannerIssue, RunnerManifest, ScenarioManifest, };

package/dist/core/planner.js

@@ -3,11 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildCompatibilityHealth = buildCompatibilityHealth;
 exports.buildUnevaluatedVerdict = buildUnevaluatedVerdict;
 exports.collectProvidedDriverActions = collectProvidedDriverActions;
+exports.collectProvidedUiContexts = collectProvidedUiContexts;
 exports.collectScenarioDriverActions = collectScenarioDriverActions;
+exports.collectScenarioUiContexts = collectScenarioUiContexts;
 exports.evaluateRunnerCompatibility = evaluateRunnerCompatibility;
 exports.intersection = intersection;
 exports.uniqueSorted = uniqueSorted;
 exports.validateScenarioAdapterOptions = validateScenarioAdapterOptions;
+const UI_DRIVER_ACTIONS = new Set([
+    'tap',
+    'scroll',
+    'assertVisible',
+    'inspectTree',
+    'screenshot',
+    'record',
+]);
 /**
  * Returns `value` when it is already an array; otherwise returns an empty array.
  *
@@ -64,6 +74,67 @@ function createIssue(code, message, metadata = {}) {
         ...metadata,
     };
 }
+/**
+ * Converts a planner issue into a capability policy entry when it affects proof strength.
+ *
+ * @param {Record<string, unknown>} issue
+ * @param {'unsupported' | 'warning'} status
+ * @returns {Record<string, unknown> | null}
+ */
+function issueToCapabilityPolicyEntry(issue, status) {
+    if (typeof issue.capability === 'string') {
+        return {
+            kind: 'capability',
+            name: issue.capability,
+            status,
+            code: issue.code,
+        };
+    }
+    if (typeof issue.driverAction === 'string') {
+        return {
+            kind: 'driverAction',
+            name: issue.driverAction,
+            status,
+            code: issue.code,
+        };
+    }
+    if (typeof issue.uiContext === 'string') {
+        return {
+            kind: 'uiContext',
+            name: issue.uiContext,
+            status,
+            code: issue.code,
+        };
+    }
+    if (typeof issue.artifact === 'string') {
+        return {
+            kind: 'artifact',
+            name: issue.artifact,
+            status,
+            code: issue.code,
+        };
+    }
+    return null;
+}
+/**
+ * Builds the no-silent-downgrade policy artifact from planner results.
+ *
+ * @param {{errors: Record<string, unknown>[], warnings: Record<string, unknown>[]}} options
+ * @returns {Record<string, unknown>}
+ */
+function buildDowngradePolicy({ errors, warnings, }) {
+    return {
+        mode: 'no-silent-downgrade',
+        allowedSubstitutions: [],
+        substitutions: [],
+        unsupported: errors
+            .map((issue) => issueToCapabilityPolicyEntry(issue, 'unsupported'))
+            .filter((entry) => entry !== null),
+        warnings: warnings
+            .map((issue) => issueToCapabilityPolicyEntry(issue, 'warning'))
+            .filter((entry) => entry !== null),
+    };
+}
 /**
  * Returns `value` when it is a plain object; otherwise returns an empty object.
  *
@@ -253,6 +324,53 @@ function collectProvidedDriverActions({ runner, evidenceProviders, effectivePlat
         ...activeProviders.flatMap((provider) => asArray(provider?.driverActions)),
     ]);
 }
+/**
+ * Collects UI/system contexts owned by the primary runner and active providers.
+ *
+ * @param {{runner: Record<string, unknown>, evidenceProviders: Record<string, unknown>[], effectivePlatforms: string[]}} options
+ * @returns {string[]}
+ */
+function collectProvidedUiContexts({ runner, evidenceProviders, effectivePlatforms, }) {
+    const activeProviders = evidenceProviders.filter((provider) => isProviderActiveForPlatforms(provider, effectivePlatforms));
+    return uniqueSorted([
+        ...asArray(runner?.uiContexts),
+        ...activeProviders.flatMap((provider) => asArray(provider?.uiContexts)),
+    ]);
+}
+/**
+ * Collects UI/system contexts required by scenario steps.
+ *
+ * @param {Record<string, unknown>} scenario
+ * @returns {{required: string[], optional: string[]}}
+ */
+function collectScenarioUiContexts(scenario) {
+    const steps = Array.isArray(scenario.steps) ? scenario.steps : [];
+    const required = [];
+    const optional = [];
+    for (const step of steps) {
+        if (!step || typeof step !== 'object') {
+            continue;
+        }
+        const uiContext = typeof step.uiContext === 'string'
+            ? step.uiContext
+            : typeof step.driverAction === 'string' && UI_DRIVER_ACTIONS.has(step.driverAction)
+                ? 'app'
+                : null;
+        if (!uiContext) {
+            continue;
+        }
+        if (step.required === false) {
+            optional.push(uiContext);
+        }
+        else {
+            required.push(uiContext);
+        }
+    }
+    return {
+        required: uniqueSorted(required),
+        optional: uniqueSorted(optional),
+    };
+}
 /**
  * Collects driver operations required by scenario steps.
  *
@@ -653,10 +771,12 @@ function evaluateRunnerCompatibility({ scenario, runner, evidenceProviders = [],
             compatible: false,
             errors,
             warnings,
+            downgradePolicy: buildDowngradePolicy({ errors, warnings }),
             matched: {
                 platforms: [],
                 capabilities: [],
                 driverActions: [],
+                uiContexts: [],
                 artifacts: [],
                 evidenceProviders: [],
             },
@@ -705,6 +825,26 @@ function evaluateRunnerCompatibility({ scenario, runner, evidenceProviders = [],
             driverAction,
         }));
     }
+    const providedUiContexts = collectProvidedUiContexts({
+        runner: primaryRunner,
+        evidenceProviders,
+        effectivePlatforms,
+    });
+    const scenarioUiContexts = collectScenarioUiContexts(scenario);
+    for (const uiContext of includesAll(providedUiContexts, scenarioUiContexts.required)) {
+        errors.push(createIssue('missing_required_ui_context', `No active runner or provider declares required UI context \`${uiContext}\`.`, {
+            runnerId: getRunnerId(primaryRunner),
+            scenarioId: getScenarioId(scenario),
+            uiContext,
+        }));
+    }
+    for (const uiContext of includesAll(providedUiContexts, scenarioUiContexts.optional)) {
+        warnings.push(createIssue('missing_optional_ui_context', `No active runner or provider declares optional UI context \`${uiContext}\`.`, {
+            runnerId: getRunnerId(primaryRunner),
+            scenarioId: getScenarioId(scenario),
+            uiContext,
+        }));
+    }
     const { activeProviders, artifacts } = collectProvidedArtifacts({
         runner: primaryRunner,
         evidenceProviders,
@@ -728,10 +868,12 @@ function evaluateRunnerCompatibility({ scenario, runner, evidenceProviders = [],
         compatible: errors.length === 0,
         errors,
         warnings,
+        downgradePolicy: buildDowngradePolicy({ errors, warnings }),
         matched: {
             platforms: effectivePlatforms,
             capabilities: providedCapabilities,
             driverActions: providedDriverActions,
+            uiContexts: providedUiContexts,
             artifacts,
             evidenceProviders: activeProviders.map((provider) => getRunnerId(provider)),
         },
@@ -769,10 +911,12 @@ function buildCompatibilityHealth({ scenario, runId, compatibility, }) {
         healthStatus: failedChecks.length > 0 ? 'failed' : 'passed',
         checks,
         ...(warningChecks.length > 0 ? { warnings: warningChecks } : {}),
+        downgradePolicy: compatibility.downgradePolicy ?? buildDowngradePolicy({ errors, warnings }),
         matched: {
             platforms: uniqueSorted(asArray(compatibility?.matched?.platforms)),
             capabilities: uniqueSorted(asArray(compatibility?.matched?.capabilities)),
             driverActions: uniqueSorted(asArray(compatibility?.matched?.driverActions)),
+            uiContexts: uniqueSorted(asArray(compatibility?.matched?.uiContexts)),
             artifacts: uniqueSorted(asArray(compatibility?.matched?.artifacts)),
             evidenceProviders: uniqueSorted(asArray(compatibility?.matched?.evidenceProviders)),
         },

package/dist/core/run-index.d.ts

@@ -1,10 +1,14 @@
 type RunIndexEntry = {
     runDir: string;
     scenarioId: string;
+    attemptId?: string;
+    attemptNumber?: number;
     scenarioHash?: string;
+    cohortHash?: string;
     runId: string;
     healthStatus: string;
     trusted: boolean;
+    trustReason: string;
     durationMs?: number;
     endedAt?: string;
     flowId?: string;

package/dist/core/run-index.js

@@ -17,6 +17,51 @@ const { ARTIFACT_FILENAMES, PROFILE_ARTIFACT_FILENAMES } = require('./artifact-l
 function readJson(filePath) {
     return JSON.parse(fs.readFileSync(filePath, 'utf8'));
 }
+/**
+ * Returns whether a value is a plain object record.
+ *
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Returns a stable reason explaining whether this run can seed latest-trusted comparisons.
+ *
+ * @param {{healthStatus: string, verdictStatus?: string, manifest: Record<string, unknown>}} options
+ * @returns {string}
+ */
+function resolveTrustReason({ healthStatus, manifest, verdictStatus, }) {
+    if (healthStatus !== 'passed') {
+        return 'health_not_passed';
+    }
+    if (verdictStatus !== 'passed') {
+        return 'verdict_not_passed';
+    }
+    const attempt = isRecord(manifest.attempt) ? manifest.attempt : null;
+    if (!attempt) {
+        return 'trusted_legacy_without_attempt';
+    }
+    if (attempt.status !== 'passed' || attempt.terminalState !== 'passed') {
+        return 'attempt_not_passed';
+    }
+    if (typeof attempt.attemptNumber === 'number' && attempt.attemptNumber !== 1) {
+        return 'retry_attempt_not_baseline_trusted';
+    }
+    if (typeof attempt.retryOfAttemptId === 'string' || typeof attempt.retryReason === 'string') {
+        return 'retry_lineage_not_baseline_trusted';
+    }
+    const cleanup = isRecord(attempt.cleanup) ? attempt.cleanup : null;
+    if (cleanup?.status === 'failed' || cleanup?.status === 'partial') {
+        return 'cleanup_not_complete';
+    }
+    const partialArtifacts = isRecord(attempt.partialArtifacts) ? attempt.partialArtifacts : null;
+    if (partialArtifacts?.valid === true) {
+        return 'partial_artifacts_not_baseline_trusted';
+    }
+    return 'trusted';
+}
 /**
  * Returns whether a directory contains the minimum run artifact pair.
  *
@@ -79,13 +124,22 @@ function readRunIndexEntry(runDir) {
             : path.basename(runDir);
     const healthStatus = typeof health.healthStatus === 'string' ? health.healthStatus : 'unknown';
     const verdictStatus = typeof verdict.verdictStatus === 'string' ? verdict.verdictStatus : undefined;
+    const provenance = isRecord(manifest.provenance) ? manifest.provenance : {};
+    const attempt = isRecord(manifest.attempt) ? manifest.attempt : null;
+    const trustReason = resolveTrustReason({ healthStatus, manifest, verdictStatus });
     return {
         runDir,
         scenarioId,
         runId,
+        ...(typeof attempt?.attemptId === 'string' ? { attemptId: attempt.attemptId } : {}),
+        ...(typeof attempt?.attemptNumber === 'number' ? { attemptNumber: attempt.attemptNumber } : {}),
         ...(typeof manifest.scenarioHash === 'string' ? { scenarioHash: manifest.scenarioHash } : {}),
+        ...(typeof provenance.cohortHash === 'string'
+            ? { cohortHash: provenance.cohortHash }
+            : {}),
         healthStatus,
-        trusted: healthStatus === 'passed' && verdictStatus === 'passed',
+        trusted: trustReason === 'trusted' || trustReason === 'trusted_legacy_without_attempt',
+        trustReason,
         ...(typeof manifest.durationMs === 'number' ? { durationMs: manifest.durationMs } : {}),
         ...(typeof manifest.endedAt === 'string' ? { endedAt: manifest.endedAt } : {}),
         ...(typeof health.flowId === 'string' ? { flowId: health.flowId } : {}),

package/dist/core/schema-validator.d.ts

@@ -46,11 +46,13 @@ declare const SCHEMAS: {
     budgetVerdict: JsonSchema;
     causalRun: JsonSchema;
     comparison: JsonSchema;
+    externalAdapterMessage: JsonSchema;
     health: JsonSchema;
     liveProof: JsonSchema;
     liveProofSet: JsonSchema;
     manifest: JsonSchema;
     metrics: JsonSchema;
+    profiler: JsonSchema;
     projectValidation: JsonSchema;
     scenario: JsonSchema;
     runnerCapabilities: JsonSchema;

package/dist/core/schema-validator.js

@@ -49,11 +49,13 @@ const SCHEMAS = {
     budgetVerdict: loadSchema('budget-verdict.schema.json'),
     causalRun: loadSchema('causal-run.schema.json'),
     comparison: loadSchema('comparison.schema.json'),
+    externalAdapterMessage: loadSchema('external-adapter-message.schema.json'),
     health: loadSchema('health.schema.json'),
     liveProof: loadSchema('live-proof.schema.json'),
     liveProofSet: loadSchema('live-proof-set.schema.json'),
     manifest: loadSchema('manifest.schema.json'),
     metrics: loadSchema('metrics.schema.json'),
+    profiler: loadSchema('profiler.schema.json'),
     projectValidation: loadSchema('project-validation.schema.json'),
     scenario: loadSchema('scenario.schema.json'),
     runnerCapabilities: loadSchema('runner-capabilities.schema.json'),