@cat-factory/contracts 0.262.0 → 0.263.0

package/dist/run-evidence.js

@@ -0,0 +1,192 @@
+import { UI_TESTER_AGENT_KIND } from './visual-pipeline.js';
+// ---------------------------------------------------------------------------
+// The rules for reading a RUN's evidence, stated once for every consumer that reduces it.
+//
+// A finished run is reduced twice today, for two audiences: the engine's PR verification report
+// (what a reviewer needs to believe the change, written onto the pull request and served at
+// `GET /api/v1/runs/:runId/report`) and the run OUTCOME summary (the non-code answer to "what
+// did this run change", served at `GET /api/v1/runs/:runId/outcome` and rendered in the SPA).
+// Two reductions is fine; two sets of RULES is not, and the second one had already drifted from
+// the first in three places before this module existed:
+//
+//  - which tester step's verdicts count (the report unions every tester step, the summary read
+//    only the last one that reported, so a pipeline carrying `tester-api` beside `tester-ui`
+//    got different coverage on the two surfaces);
+//  - what `not_covered` counts (the report enumerates the SPEC, so a requirement nobody looked
+//    at is reported as unchecked; the summary enumerated the tester's own verdicts, so the same
+//    requirement was invisible and both surfaces printed a number called "not covered");
+//  - what a REGRESSION is (the same rule, written out twice);
+//  - which BRANCH the spec is read from, the one that decides whether the join has anything to
+//    match at all (see {@link runSpecBranch}).
+//
+// So the rules live here, in the package both the backend and the SPA compile against, and the
+// two reductions call them rather than restating them. What each surface still owns is its own
+// PRESENTATION and its own absence policy: the report withholds a section it cannot compute and
+// says so in prose, the summary carries a machine-readable gap code the SPA maps to translated
+// copy. Those genuinely differ. The facts underneath may not.
+// ---------------------------------------------------------------------------
+/** The API tester gate's agent kind. */
+export const TESTER_AGENT_KIND = 'tester-api';
+/**
+ * Whether an agent kind is one of the tester gate kinds (API or UI).
+ *
+ * Here rather than in each consumer because every reduction of a run's test evidence starts by
+ * answering it, and the two copies that preceded this one spelled the kinds out as literals on
+ * one side and as constants on the other.
+ */
+export function isTesterKind(kind) {
+    return kind === TESTER_AGENT_KIND || kind === UI_TESTER_AGENT_KIND;
+}
+/**
+ * The step a section should report on: the LAST matching step that carries evidence, else the
+ * first matching step.
+ *
+ * Last-with-evidence, not first-match: a pipeline may legitimately carry the same kind twice (a
+ * `ci` gate after the coder and another after the tester), and the later run describes the head
+ * as it stands now. Falling back to the first match rather than to nothing is what lets a
+ * consumer tell "this pipeline has no such step" from "it has one and it has not reported yet",
+ * which are opposite facts that a single `null` states identically.
+ */
+export function selectEvidenceStep(steps, matches, hasEvidence) {
+    const matching = steps.filter(matches);
+    for (let i = matching.length - 1; i >= 0; i -= 1) {
+        if (hasEvidence(matching[i]))
+            return matching[i];
+    }
+    return matching[0];
+}
+/** Every tester step of a run, in pipeline order. */
+export function testerSteps(steps) {
+    return steps.filter((step) => isTesterKind(step.agentKind));
+}
+/**
+ * The tester step whose report describes the work as it stands: the last one that reported,
+ * else the first tester step in the pipeline (see {@link selectEvidenceStep}).
+ */
+export function selectTesterReportStep(steps) {
+    return selectEvidenceStep(steps, (step) => isTesterKind(step.agentKind), (step) => step.test?.lastReport != null);
+}
+/**
+ * Index a run's requirement verdicts by the spec's own requirement id, across EVERY tester step
+ * in pipeline order.
+ *
+ * Every tester step, not just the one whose report a `tests` section shows: a pipeline carrying
+ * both `tester-api` and `tester-ui` promotes requirements off both kinds' verdicts, so a join
+ * reading only the last of them shows "not checked" against requirements the spec already
+ * records as `established`.
+ *
+ * A duplicate id keeps the FIRST verdict, whether it repeats within one report or across two
+ * testers, because last-wins would let a trailing `not_covered` quietly erase a real
+ * observation, which is the one thing a coverage join exists to prevent.
+ */
+export function indexRequirementVerdicts(steps) {
+    const byId = new Map();
+    for (const step of testerSteps(steps)) {
+        for (const verdict of step.test?.lastReport?.requirementVerdicts ?? []) {
+            if (!byId.has(verdict.requirementId))
+                byId.set(verdict.requirementId, verdict);
+        }
+    }
+    return byId;
+}
+/**
+ * Join the service's in-repo `spec/` to a run's requirement verdicts, in spec order (module →
+ * group → requirement).
+ *
+ * A requirement the tester said nothing about is `not_covered`, NEVER `not_met`: silence means
+ * nobody looked, and rendering that as a failure would make every unrelated change look like it
+ * broke the service.
+ */
+export function joinSpecRequirements(spec, verdicts) {
+    const rows = [];
+    for (const module of spec.modules ?? []) {
+        for (const group of module.groups ?? []) {
+            for (const requirement of group.requirements ?? []) {
+                const verdict = verdicts.get(requirement.id);
+                rows.push({
+                    id: requirement.id,
+                    title: requirement.title,
+                    module: module.name,
+                    group: group.name,
+                    priority: requirement.priority,
+                    state: requirement.state ?? 'aspirational',
+                    verdict: verdict?.status ?? 'not_covered',
+                    detail: verdict?.detail?.trim() || null,
+                    criteriaCount: (requirement.acceptance ?? []).length,
+                });
+            }
+        }
+    }
+    return rows;
+}
+/**
+ * The verdict ids the join could NOT place: ids the tester ruled on that the spec does not
+ * carry.
+ *
+ * Shared for the same reason the join is: the difference between a coverage section's rulings
+ * and the tester's own is otherwise unexplainable, and it reads as a miscount in whichever of
+ * the two the reader trusts less. Two spellings of "which ids went missing" would be a third
+ * way for the two documents to print different numbers for one run.
+ *
+ * It is also the fact that tells an EMPTY join apart from an ABSENT one: a spec declaring no
+ * requirements against a tester that ruled on nothing is genuinely nothing to report, while the
+ * same spec against a tester that returned verdicts is a spec that moved on under the run, and
+ * the verdicts are the only evidence there is.
+ */
+export function unmatchedVerdictIds(rows, verdicts) {
+    const known = new Set(rows.map((row) => row.id));
+    return [...verdicts.keys()].filter((id) => !known.has(id));
+}
+/**
+ * The branch a run's `spec/` must be read from: the branch the run pushed its work to, else the
+ * repo's default.
+ *
+ * Stated here because THREE readers need the same answer and two of them had already disagreed:
+ * the engine's evidence loader read the run's branch while the SPA's spec fetch read the default,
+ * so an in-flight run's outcome card joined this run's verdicts against a spec that does not yet
+ * carry the requirements it just ruled on. Every one of those rows lands as "not checked", and
+ * the card's counts contradict `GET /api/v1/runs/:runId/outcome` for the same run.
+ *
+ * The run's branch, not the default, is the truthful denominator: the spec increment this task
+ * wrote has not merged yet, and the verdicts were made against the tree as it stands on that
+ * branch. Once the pull request merges the two answers converge, which is why the fallback is
+ * the default branch rather than an absence.
+ */
+export function runSpecBranch(block, defaultBranch) {
+    return block.pullRequest?.branch ?? defaultBranch;
+}
+/**
+ * Whether a row is a REGRESSION: behaviour the spec records as `established` (observed to hold
+ * on some earlier run, which is the only thing that makes it standing behaviour) that this run's
+ * tester observed to FAIL.
+ *
+ * The one derived fact the implementation-state axis exists to make computable, and the only
+ * reading of a coverage section that says the change BROKE something rather than merely not
+ * finishing it. Left uncomputed, an aspirational failure and a lost behaviour reach a reader as
+ * the same `not met` cell.
+ */
+export function isRequirementRegression(row) {
+    return row.state === 'established' && row.verdict === 'not_met';
+}
+/**
+ * Count a join. Over every row and before any cap, so a surface that shows a bounded table still
+ * reports the true totals.
+ */
+export function tallyRequirements(rows) {
+    const count = (status) => rows.filter((row) => row.verdict === status).length;
+    return {
+        met: count('met'),
+        notMet: count('not_met'),
+        notCovered: count('not_covered'),
+        regressions: rows.filter(isRequirementRegression).length,
+        total: rows.length,
+    };
+}
+/** Tally a tester report's per-area outcomes. */
+export function tallyTestOutcomes(report) {
+    const tally = { passed: 0, failed: 0, skipped: 0 };
+    for (const outcome of report.outcomes)
+        tally[outcome.status] += 1;
+    return tally;
+}
+//# sourceMappingURL=run-evidence.js.map

package/dist/run-evidence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-evidence.js","sourceRoot":"","sources":["../src/run-evidence.ts"],"names":[],"mappings":"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"}

package/dist/run-outcome.d.ts

@@ -0,0 +1,370 @@
+import * as v from 'valibot';
+import type { Block } from './entities.js';
+import type { ExecutionInstance } from './execution.js';
+import type { ServiceSpecView } from './spec.js';
+/**
+ * The wire version of the outcome payload. Bumped when the shape gains something an external
+ * consumer would want to notice; never a compatibility switch (the surface is additive, so a
+ * consumer written against an older number keeps reading the fields it knows).
+ */
+export declare const RUN_OUTCOME_VERSION = 1;
+/**
+ * Where the run stands, in the terms the person reading the outcome cares about. Derived from
+ * the BLOCK's status first (it is what the merge lifecycle writes) and from the run only for
+ * the states a block cannot distinguish.
+ */
+export declare const outcomeDispositionSchema: v.PicklistSchema<["merged", "awaiting_merge", "in_flight", "needs_attention", "not_run", "unknown"], undefined>;
+export type OutcomeDisposition = v.InferOutput<typeof outcomeDispositionSchema>;
+/** One pull request the run opened: the own-service PR, plus a peer PR per connected repo. */
+export declare const outcomePullRequestSchema: v.ObjectSchema<{
+    readonly url: v.StringSchema<undefined>;
+    readonly number: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    readonly branch: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** `owner/name` for a PEER repo's PR; null for the task's own service. */
+    readonly repo: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type OutcomePullRequest = v.InferOutput<typeof outcomePullRequestSchema>;
+/**
+ * The gap EVERY evidence section shares: the block names a run (`block.executionId`) the
+ * caller could not resolve, so nothing any step recorded is knowable here.
+ *
+ * It is kept apart from every other gap in this module, which report what a RESOLVED run did
+ * or did not produce. "The store does not have this run" and "this pipeline has no tester
+ * step" are opposite facts about opposite things, and a summary that reported the second for
+ * the first would blame the pipeline for a read that never happened, on the one surface whose
+ * whole job is to say what is known and what is not.
+ */
+export declare const runUnavailableGap = "run_unavailable";
+export type RunUnavailableGap = typeof runUnavailableGap;
+/** Why there is no requirement coverage to show. Each needs a different reaction. */
+export declare const requirementsGapSchema: v.PicklistSchema<["run_unavailable", "no_tester_step", "tester_not_reported", "no_verdicts", "no_requirements"], undefined>;
+export type RequirementsGap = v.InferOutput<typeof requirementsGapSchema>;
+/**
+ * Whether the coverage was counted against the service's `spec/`, or only against the ids the
+ * tester keyed its verdicts by.
+ *
+ * `joined` is the real answer: every requirement the service declares is a row, so one nobody
+ * looked at is reported as unchecked. `not_read` is the degraded one, and it is a different
+ * DENOMINATOR rather than a cosmetic loss of titles: the counts describe what the tester ruled
+ * on and say nothing about what it skipped. It is a real state on both consumers (the SPA
+ * renders before its spec fetch lands; a deployment with no VCS wired can never read one), so
+ * it is stated rather than collapsed into an absence.
+ */
+export declare const outcomeSpecJoinSchema: v.PicklistSchema<["joined", "not_read"], undefined>;
+export type OutcomeSpecJoin = v.InferOutput<typeof outcomeSpecJoinSchema>;
+/** One requirement, paired with what the tester observed about it. */
+export declare const outcomeRequirementSchema: v.ObjectSchema<{
+    /** The spec requirement id: the join key, and all there is when the spec was not read. */
+    readonly id: v.StringSchema<undefined>;
+    /** The requirement's headline from `spec/`; null on an unjoined row. */
+    readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly verdict: v.PicklistSchema<["met", "not_met", "not_covered"], undefined>;
+    /** What the tester observed, when it said. */
+    readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** Implementation state as `spec/` recorded it, or null when unjoined. */
+    readonly state: v.NullableSchema<v.PicklistSchema<["aspirational", "established"], undefined>, undefined>;
+    /**
+     * An `established` requirement the tester observed to FAIL: behaviour the platform had
+     * previously seen hold and no longer does. Computed here, never read off a report, and the
+     * one reading of this section that says the change BROKE something rather than merely not
+     * finishing it. An `aspirational` requirement failing is in-flight work, not a regression.
+     */
+    readonly regression: v.BooleanSchema<undefined>;
+}, undefined>;
+export type OutcomeRequirement = v.InferOutput<typeof outcomeRequirementSchema>;
+export declare const outcomeRequirementsSchema: v.VariantSchema<"status", [v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"absent", undefined>;
+    readonly gap: v.PicklistSchema<["run_unavailable", "no_tester_step", "tester_not_reported", "no_verdicts", "no_requirements"], undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"reported", undefined>;
+    /** What the counts below are counted over. See {@link outcomeSpecJoinSchema}. */
+    readonly spec: v.PicklistSchema<["joined", "not_read"], undefined>;
+    readonly met: v.NumberSchema<undefined>;
+    readonly notMet: v.NumberSchema<undefined>;
+    readonly notCovered: v.NumberSchema<undefined>;
+    /** A SUBSET of `notMet`; see {@link outcomeRequirementSchema.entries.regression}. */
+    readonly regressions: v.NumberSchema<undefined>;
+    /**
+     * `met + notMet + notCovered`, and the DENOMINATOR the three are read against. Carried rather
+     * than left to the reader to add up, because what it counts depends on `spec`: joined, it is
+     * every requirement the service declares; unjoined, only the ones the tester ruled on.
+     */
+    readonly total: v.NumberSchema<undefined>;
+    /**
+     * Verdicts the tester returned against ids the spec does not carry, which the join can
+     * neither place nor count. Non-zero means the spec moved on under the tester (or that it
+     * keyed its verdicts by something else), and a reader comparing the totals to the tester's
+     * own report needs to know the difference is not a miscount. Always 0 on a `not_read`
+     * section, where there is nothing to match against.
+     */
+    readonly unmatchedVerdicts: v.NumberSchema<undefined>;
+    /** Regressions first, then failures, then what was met, then what nobody checked. */
+    readonly entries: v.ArraySchema<v.ObjectSchema<{
+        /** The spec requirement id: the join key, and all there is when the spec was not read. */
+        readonly id: v.StringSchema<undefined>;
+        /** The requirement's headline from `spec/`; null on an unjoined row. */
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly verdict: v.PicklistSchema<["met", "not_met", "not_covered"], undefined>;
+        /** What the tester observed, when it said. */
+        readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** Implementation state as `spec/` recorded it, or null when unjoined. */
+        readonly state: v.NullableSchema<v.PicklistSchema<["aspirational", "established"], undefined>, undefined>;
+        /**
+         * An `established` requirement the tester observed to FAIL: behaviour the platform had
+         * previously seen hold and no longer does. Computed here, never read off a report, and the
+         * one reading of this section that says the change BROKE something rather than merely not
+         * finishing it. An `aspirational` requirement failing is in-flight work, not a regression.
+         */
+        readonly regression: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>], undefined>;
+export type OutcomeRequirements = v.InferOutput<typeof outcomeRequirementsSchema>;
+export declare const testsGapSchema: v.PicklistSchema<["run_unavailable", "no_tester_step", "tester_not_reported"], undefined>;
+export type TestsGap = v.InferOutput<typeof testsGapSchema>;
+/**
+ * The tester's disposition. `could_not_run` is kept apart from `concerns` because they call
+ * for opposite reactions: one is a change with bugs in it, the other is a change nobody
+ * managed to exercise at all, and a report that collapses them reads as tested either way.
+ */
+export declare const testsVerdictSchema: v.PicklistSchema<["greenlit", "concerns", "could_not_run"], undefined>;
+export type TestsVerdict = v.InferOutput<typeof testsVerdictSchema>;
+export declare const outcomeConcernSchema: v.ObjectSchema<{
+    readonly title: v.StringSchema<undefined>;
+    readonly severity: v.PicklistSchema<["low", "medium", "high", "critical"], undefined>;
+}, undefined>;
+export type OutcomeConcern = v.InferOutput<typeof outcomeConcernSchema>;
+export declare const outcomeTestsSchema: v.VariantSchema<"status", [v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"absent", undefined>;
+    readonly gap: v.PicklistSchema<["run_unavailable", "no_tester_step", "tester_not_reported"], undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"reported", undefined>;
+    readonly verdict: v.PicklistSchema<["greenlit", "concerns", "could_not_run"], undefined>;
+    /** The tester's own prose about the session, attributed as such at the render site. */
+    readonly summary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** Verbatim reason the tester could not run at all; null unless `could_not_run`. */
+    readonly abortReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** What it exercised, by name. */
+    readonly areas: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly passed: v.NumberSchema<undefined>;
+    readonly failed: v.NumberSchema<undefined>;
+    readonly skipped: v.NumberSchema<undefined>;
+    readonly concerns: v.ArraySchema<v.ObjectSchema<{
+        readonly title: v.StringSchema<undefined>;
+        readonly severity: v.PicklistSchema<["low", "medium", "high", "critical"], undefined>;
+    }, undefined>, undefined>;
+    readonly environment: v.NullableSchema<v.PicklistSchema<["local", "ephemeral"], undefined>, undefined>;
+}, undefined>], undefined>;
+export type OutcomeTests = v.InferOutput<typeof outcomeTestsSchema>;
+export declare const visualsGapSchema: v.PicklistSchema<["run_unavailable", "no_visual_step", "none_captured"], undefined>;
+export type VisualsGap = v.InferOutput<typeof visualsGapSchema>;
+/** One captured view, paired with the reference design it was reviewed against when there is one. */
+export declare const outcomeVisualSchema: v.ObjectSchema<{
+    readonly view: v.StringSchema<undefined>;
+    readonly artifactId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly referenceArtifactId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type OutcomeVisual = v.InferOutput<typeof outcomeVisualSchema>;
+export declare const outcomeVisualsSchema: v.VariantSchema<"status", [v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"absent", undefined>;
+    readonly gap: v.PicklistSchema<["run_unavailable", "no_visual_step", "none_captured"], undefined>;
+    /** The gate's own verbatim explanation, when it recorded one. Detail, never the headline. */
+    readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"reported", undefined>;
+    /**
+     * Which producer the views came from. `visual_confirm` pairs were put in front of a
+     * human and carry a verdict; `tester` shots are captures nobody was asked about, and the
+     * summary must not let the second read as the first.
+     */
+    readonly source: v.PicklistSchema<["visual_confirm", "tester"], undefined>;
+    /** The gate's phase when the views came from it: awaiting a human, fixing, or approved. */
+    readonly phase: v.NullableSchema<v.PicklistSchema<["awaiting_human", "fixing", "approved"], undefined>, undefined>;
+    readonly views: v.ArraySchema<v.ObjectSchema<{
+        readonly view: v.StringSchema<undefined>;
+        readonly artifactId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly referenceArtifactId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>], undefined>;
+export type OutcomeVisuals = v.InferOutput<typeof outcomeVisualsSchema>;
+/** The three recorded machine verdicts a non-code reader still needs: did it build, does it work. */
+export declare const outcomeCheckKindSchema: v.PicklistSchema<["ci", "validation", "reproduction"], undefined>;
+export type OutcomeCheckKind = v.InferOutput<typeof outcomeCheckKindSchema>;
+export declare const outcomeCheckStateSchema: v.PicklistSchema<["pass", "fail", "pending", "inconclusive"], undefined>;
+export type OutcomeCheckState = v.InferOutput<typeof outcomeCheckStateSchema>;
+export declare const outcomeCheckSchema: v.ObjectSchema<{
+    readonly kind: v.PicklistSchema<["ci", "validation", "reproduction"], undefined>;
+    readonly state: v.PicklistSchema<["pass", "fail", "pending", "inconclusive"], undefined>;
+    /**
+     * The producer's own qualifier, when the state alone would under-report it: the reproduction
+     * verdict that earned an `inconclusive`. Rendered through an exhaustive map, never as prose.
+     */
+    readonly reproduction: v.NullableSchema<v.PicklistSchema<["reproduced", "inconclusive", "declared_infeasible"], undefined>, undefined>;
+}, undefined>;
+export type OutcomeCheck = v.InferOutput<typeof outcomeCheckSchema>;
+export declare const runOutcomeSchema: v.ObjectSchema<{
+    /** See {@link RUN_OUTCOME_VERSION}. */
+    readonly version: v.NumberSchema<undefined>;
+    readonly disposition: v.PicklistSchema<["merged", "awaiting_merge", "in_flight", "needs_attention", "not_run", "unknown"], undefined>;
+    /** The task's title: the product-language name of what was asked for. */
+    readonly title: v.StringSchema<undefined>;
+    /** The requester's own description of the ask, trimmed; null when the task carried none. */
+    readonly ask: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** Every PR the run opened, so the diff stays exactly one click from the summary. */
+    readonly pullRequests: v.ArraySchema<v.ObjectSchema<{
+        readonly url: v.StringSchema<undefined>;
+        readonly number: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        readonly branch: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** `owner/name` for a PEER repo's PR; null for the task's own service. */
+        readonly repo: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly requirements: v.VariantSchema<"status", [v.ObjectSchema<{
+        readonly status: v.LiteralSchema<"absent", undefined>;
+        readonly gap: v.PicklistSchema<["run_unavailable", "no_tester_step", "tester_not_reported", "no_verdicts", "no_requirements"], undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly status: v.LiteralSchema<"reported", undefined>;
+        /** What the counts below are counted over. See {@link outcomeSpecJoinSchema}. */
+        readonly spec: v.PicklistSchema<["joined", "not_read"], undefined>;
+        readonly met: v.NumberSchema<undefined>;
+        readonly notMet: v.NumberSchema<undefined>;
+        readonly notCovered: v.NumberSchema<undefined>;
+        /** A SUBSET of `notMet`; see {@link outcomeRequirementSchema.entries.regression}. */
+        readonly regressions: v.NumberSchema<undefined>;
+        /**
+         * `met + notMet + notCovered`, and the DENOMINATOR the three are read against. Carried rather
+         * than left to the reader to add up, because what it counts depends on `spec`: joined, it is
+         * every requirement the service declares; unjoined, only the ones the tester ruled on.
+         */
+        readonly total: v.NumberSchema<undefined>;
+        /**
+         * Verdicts the tester returned against ids the spec does not carry, which the join can
+         * neither place nor count. Non-zero means the spec moved on under the tester (or that it
+         * keyed its verdicts by something else), and a reader comparing the totals to the tester's
+         * own report needs to know the difference is not a miscount. Always 0 on a `not_read`
+         * section, where there is nothing to match against.
+         */
+        readonly unmatchedVerdicts: v.NumberSchema<undefined>;
+        /** Regressions first, then failures, then what was met, then what nobody checked. */
+        readonly entries: v.ArraySchema<v.ObjectSchema<{
+            /** The spec requirement id: the join key, and all there is when the spec was not read. */
+            readonly id: v.StringSchema<undefined>;
+            /** The requirement's headline from `spec/`; null on an unjoined row. */
+            readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly verdict: v.PicklistSchema<["met", "not_met", "not_covered"], undefined>;
+            /** What the tester observed, when it said. */
+            readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            /** Implementation state as `spec/` recorded it, or null when unjoined. */
+            readonly state: v.NullableSchema<v.PicklistSchema<["aspirational", "established"], undefined>, undefined>;
+            /**
+             * An `established` requirement the tester observed to FAIL: behaviour the platform had
+             * previously seen hold and no longer does. Computed here, never read off a report, and the
+             * one reading of this section that says the change BROKE something rather than merely not
+             * finishing it. An `aspirational` requirement failing is in-flight work, not a regression.
+             */
+            readonly regression: v.BooleanSchema<undefined>;
+        }, undefined>, undefined>;
+    }, undefined>], undefined>;
+    readonly tests: v.VariantSchema<"status", [v.ObjectSchema<{
+        readonly status: v.LiteralSchema<"absent", undefined>;
+        readonly gap: v.PicklistSchema<["run_unavailable", "no_tester_step", "tester_not_reported"], undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly status: v.LiteralSchema<"reported", undefined>;
+        readonly verdict: v.PicklistSchema<["greenlit", "concerns", "could_not_run"], undefined>;
+        /** The tester's own prose about the session, attributed as such at the render site. */
+        readonly summary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** Verbatim reason the tester could not run at all; null unless `could_not_run`. */
+        readonly abortReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** What it exercised, by name. */
+        readonly areas: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly passed: v.NumberSchema<undefined>;
+        readonly failed: v.NumberSchema<undefined>;
+        readonly skipped: v.NumberSchema<undefined>;
+        readonly concerns: v.ArraySchema<v.ObjectSchema<{
+            readonly title: v.StringSchema<undefined>;
+            readonly severity: v.PicklistSchema<["low", "medium", "high", "critical"], undefined>;
+        }, undefined>, undefined>;
+        readonly environment: v.NullableSchema<v.PicklistSchema<["local", "ephemeral"], undefined>, undefined>;
+    }, undefined>], undefined>;
+    readonly visuals: v.VariantSchema<"status", [v.ObjectSchema<{
+        readonly status: v.LiteralSchema<"absent", undefined>;
+        readonly gap: v.PicklistSchema<["run_unavailable", "no_visual_step", "none_captured"], undefined>;
+        /** The gate's own verbatim explanation, when it recorded one. Detail, never the headline. */
+        readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly status: v.LiteralSchema<"reported", undefined>;
+        /**
+         * Which producer the views came from. `visual_confirm` pairs were put in front of a
+         * human and carry a verdict; `tester` shots are captures nobody was asked about, and the
+         * summary must not let the second read as the first.
+         */
+        readonly source: v.PicklistSchema<["visual_confirm", "tester"], undefined>;
+        /** The gate's phase when the views came from it: awaiting a human, fixing, or approved. */
+        readonly phase: v.NullableSchema<v.PicklistSchema<["awaiting_human", "fixing", "approved"], undefined>, undefined>;
+        readonly views: v.ArraySchema<v.ObjectSchema<{
+            readonly view: v.StringSchema<undefined>;
+            readonly artifactId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly referenceArtifactId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>], undefined>;
+    /** Only the checks that actually ran: an absent check is omitted, never rendered as passing. */
+    readonly checks: v.ArraySchema<v.ObjectSchema<{
+        readonly kind: v.PicklistSchema<["ci", "validation", "reproduction"], undefined>;
+        readonly state: v.PicklistSchema<["pass", "fail", "pending", "inconclusive"], undefined>;
+        /**
+         * The producer's own qualifier, when the state alone would under-report it: the reproduction
+         * verdict that earned an `inconclusive`. Rendered through an exhaustive map, never as prose.
+         */
+        readonly reproduction: v.NullableSchema<v.PicklistSchema<["reproduced", "inconclusive", "declared_infeasible"], undefined>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * What a BOUNDED rendering of this summary had to leave out, one note per capped list
+     * (`"requirements.entries: showing 200 of 480"`), in the same vocabulary the verification
+     * report's own `truncations` uses. Empty whenever nothing was dropped, which is every
+     * ordinary run and every composition the SPA does (it renders from state it already holds and
+     * caps nothing).
+     *
+     * It exists because the counts above are computed over the WHOLE join, before any cap: a
+     * consumer that found 200 rows under a `total` of 480 and no note would have to guess whether
+     * the tail was never ruled on. A cap that is not a plain prefix says so in its note, since
+     * `entries` is ordered by SEVERITY and the rows a cap drops are therefore the least severe
+     * ones rather than the end of the spec.
+     */
+    readonly truncations: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type RunOutcome = v.InferOutput<typeof runOutcomeSchema>;
+/**
+ * Parse-or-throw an outcome payload, for any consumer proving the JSON it holds is this shape.
+ */
+export declare function parseRunOutcome(value: unknown): RunOutcome;
+export interface ComposeRunOutcomeInput {
+    block: Block;
+    /**
+     * The run, or null when the caller has none. Null is TWO facts, and the block tells them
+     * apart: a task with no `executionId` never ran, while a task that names one the caller
+     * could not resolve has run and this summary simply cannot see it (see
+     * {@link runUnavailableGap}). Callers pass what their store holds and never substitute one
+     * for the other.
+     */
+    instance: ExecutionInstance | null;
+    /** The enclosing service's spec, when it has been loaded. Absent ⇒ ids without titles. */
+    spec?: ServiceSpecView | null;
+}
+/**
+ * Compose a run's outcome summary from what the run already carries. Pure: every input is a
+ * value the caller read off its store (the SPA) or off its repositories (the API), so the whole
+ * reduction unit-tests without mounting the window that renders it, and the two surfaces cannot
+ * answer the same question differently.
+ */
+export declare function composeRunOutcome({ block, instance, spec }: ComposeRunOutcomeInput): RunOutcome;
+/**
+ * Whether a run has anything an outcome summary could show beyond the task's own title: a PR to
+ * open, or a step that recorded evidence. EVERY entry point asks this (the board card and the
+ * inspector alike, off the one reduction, so they can never disagree) so the affordance appears
+ * on a run that produced something and stays absent on one that has not yet, rather than
+ * offering a summary whose every section reads "nothing here".
+ *
+ * A run this summary could not resolve answers false unless the block still carries a pull
+ * request: there is nothing to show, and an affordance that opened onto four "not loaded"
+ * notices would be the same empty card by another route.
+ */
+export declare function hasOutcomeToShow(outcome: RunOutcome): boolean;
+//# sourceMappingURL=run-outcome.d.ts.map

package/dist/run-outcome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-outcome.d.ts","sourceRoot":"","sources":["../src/run-outcome.ts"],"names":[],"mappings":"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"}