@cat-factory/contracts 0.261.1 → 0.263.0

package/dist/routes/public-evidence.d.ts

@@ -171,6 +171,7 @@ export declare const getPublicRunReportContract: {
                 readonly notCovered: import("valibot").NumberSchema<undefined>;
                 readonly regressions: import("valibot").NumberSchema<undefined>;
                 readonly total: import("valibot").NumberSchema<undefined>;
+                readonly unmatchedVerdicts: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
             }, undefined>;
             readonly environments: import("valibot").ObjectSchema<{
                 readonly status: import("valibot").PicklistSchema<["reported", "absent"], undefined>;
@@ -256,6 +257,128 @@ export declare const getPublicRunReportContract: {
             readonly truncations: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
         }, undefined>;
     };
+} & {
+    readonly minScope: "read";
+};
+/**
+ * The run's OUTCOME summary: what it changed and what backs that up, for a reader who will not
+ * open the diff.
+ *
+ * The sibling of the report above rather than a projection of it, and the difference is the
+ * AUDIENCE, not the facts: the report is a reviewer's evidence bundle (every failing check by
+ * name, every captured log tail, the merge assessment), this is the product-language answer the
+ * app's outcome card renders, and the counts underneath both are computed by the same shared
+ * rules. A consumer deciding whether a change is acceptable wants the report; one reporting to a
+ * person what shipped wants this.
+ *
+ * Deliberately not derived from the report on the wire: the report is BOUNDED to what fits in a
+ * pull-request body, and a tally taken off its capped tables would be quietly wrong.
+ */
+export declare const getPublicRunOutcomeContract: {
+    readonly method: "get";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        runId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ runId }: {
+        runId: string;
+    }) => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly version: import("valibot").NumberSchema<undefined>;
+            readonly disposition: import("valibot").PicklistSchema<["merged", "awaiting_merge", "in_flight", "needs_attention", "not_run", "unknown"], undefined>;
+            readonly title: import("valibot").StringSchema<undefined>;
+            readonly ask: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly pullRequests: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly url: import("valibot").StringSchema<undefined>;
+                readonly number: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                readonly branch: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly repo: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+            readonly requirements: import("valibot").VariantSchema<"status", [import("valibot").ObjectSchema<{
+                readonly status: import("valibot").LiteralSchema<"absent", undefined>;
+                readonly gap: import("valibot").PicklistSchema<["run_unavailable", "no_tester_step", "tester_not_reported", "no_verdicts", "no_requirements"], undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly status: import("valibot").LiteralSchema<"reported", undefined>;
+                readonly spec: import("valibot").PicklistSchema<["joined", "not_read"], undefined>;
+                readonly met: import("valibot").NumberSchema<undefined>;
+                readonly notMet: import("valibot").NumberSchema<undefined>;
+                readonly notCovered: import("valibot").NumberSchema<undefined>;
+                readonly regressions: import("valibot").NumberSchema<undefined>;
+                readonly total: import("valibot").NumberSchema<undefined>;
+                readonly unmatchedVerdicts: import("valibot").NumberSchema<undefined>;
+                readonly entries: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly title: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly verdict: import("valibot").PicklistSchema<["met", "not_met", "not_covered"], undefined>;
+                    readonly detail: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly state: import("valibot").NullableSchema<import("valibot").PicklistSchema<["aspirational", "established"], undefined>, undefined>;
+                    readonly regression: import("valibot").BooleanSchema<undefined>;
+                }, undefined>, undefined>;
+            }, undefined>], undefined>;
+            readonly tests: import("valibot").VariantSchema<"status", [import("valibot").ObjectSchema<{
+                readonly status: import("valibot").LiteralSchema<"absent", undefined>;
+                readonly gap: import("valibot").PicklistSchema<["run_unavailable", "no_tester_step", "tester_not_reported"], undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly status: import("valibot").LiteralSchema<"reported", undefined>;
+                readonly verdict: import("valibot").PicklistSchema<["greenlit", "concerns", "could_not_run"], undefined>;
+                readonly summary: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly abortReason: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly areas: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly passed: import("valibot").NumberSchema<undefined>;
+                readonly failed: import("valibot").NumberSchema<undefined>;
+                readonly skipped: import("valibot").NumberSchema<undefined>;
+                readonly concerns: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly title: import("valibot").StringSchema<undefined>;
+                    readonly severity: import("valibot").PicklistSchema<["low", "medium", "high", "critical"], undefined>;
+                }, undefined>, undefined>;
+                readonly environment: import("valibot").NullableSchema<import("valibot").PicklistSchema<["local", "ephemeral"], undefined>, undefined>;
+            }, undefined>], undefined>;
+            readonly visuals: import("valibot").VariantSchema<"status", [import("valibot").ObjectSchema<{
+                readonly status: import("valibot").LiteralSchema<"absent", undefined>;
+                readonly gap: import("valibot").PicklistSchema<["run_unavailable", "no_visual_step", "none_captured"], undefined>;
+                readonly detail: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly status: import("valibot").LiteralSchema<"reported", undefined>;
+                readonly source: import("valibot").PicklistSchema<["visual_confirm", "tester"], undefined>;
+                readonly phase: import("valibot").NullableSchema<import("valibot").PicklistSchema<["awaiting_human", "fixing", "approved"], undefined>, undefined>;
+                readonly views: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly view: import("valibot").StringSchema<undefined>;
+                    readonly artifactId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly referenceArtifactId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>], undefined>;
+            readonly checks: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly kind: import("valibot").PicklistSchema<["ci", "validation", "reproduction"], undefined>;
+                readonly state: import("valibot").PicklistSchema<["pass", "fail", "pending", "inconclusive"], undefined>;
+                readonly reproduction: import("valibot").NullableSchema<import("valibot").PicklistSchema<["reproduced", "inconclusive", "declared_infeasible"], undefined>, undefined>;
+            }, undefined>, undefined>;
+            readonly truncations: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "read";
 };
 /** The binary artifacts the run captured (metadata; the bytes are a second, per-artifact fetch). */
 export declare const listPublicRunArtifactsContract: {
@@ -301,5 +424,7 @@ export declare const listPublicRunArtifactsContract: {
             }, undefined>, undefined>;
         }, undefined>;
     };
+} & {
+    readonly minScope: "read";
 };
 //# sourceMappingURL=public-evidence.d.ts.map

package/dist/routes/public-evidence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public-evidence.d.ts","sourceRoot":"","sources":["../../src/routes/public-evidence.ts"],"names":[],"mappings":"AAwBA;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKrC,CAAA;AAEF,oGAAoG;AACpG,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKzC,CAAA"}
+{"version":3,"file":"public-evidence.d.ts","sourceRoot":"","sources":["../../src/routes/public-evidence.ts"],"names":[],"mappings":"AAyBA;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQtC,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQvC,CAAA;AAED,oGAAoG;AACpG,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ1C,CAAA"}

package/dist/routes/public-evidence.js

@@ -1,7 +1,8 @@
 import { defineApiContract } from '@toad-contracts/valibot';
 import { prVerificationReportSchema } from '../pr-report.js';
 import { publicRunArtifactListSchema } from '../public-evidence.js';
-import { errorResponses, singleStringParam } from './_shared.js';
+import { runOutcomeSchema } from '../run-outcome.js';
+import { errorResponses, singleStringParam, withMinScope } from './_shared.js';
 // ---------------------------------------------------------------------------
 // Route contracts for the public run-EVIDENCE surface: absolute `/api/v1` paths,
 // authenticated in-controller by a public-API key at `read` scope. The wire shapes and the
@@ -26,17 +27,37 @@ const runIdParams = singleStringParam('runId');
  * A consumer that scraped the fenced JSON block out of a PR body can read it here instead, and
  * gets it for the runs that never opened a pull request at all.
  */
-export const getPublicRunReportContract = defineApiContract({
+export const getPublicRunReportContract = withMinScope('read', defineApiContract({
     method: 'get',
     requestPathParamsSchema: runIdParams,
     pathResolver: ({ runId }) => `/api/v1/runs/${runId}/report`,
     responsesByStatusCode: { 200: prVerificationReportSchema, ...errorResponses },
-});
+}));
+/**
+ * The run's OUTCOME summary: what it changed and what backs that up, for a reader who will not
+ * open the diff.
+ *
+ * The sibling of the report above rather than a projection of it, and the difference is the
+ * AUDIENCE, not the facts: the report is a reviewer's evidence bundle (every failing check by
+ * name, every captured log tail, the merge assessment), this is the product-language answer the
+ * app's outcome card renders, and the counts underneath both are computed by the same shared
+ * rules. A consumer deciding whether a change is acceptable wants the report; one reporting to a
+ * person what shipped wants this.
+ *
+ * Deliberately not derived from the report on the wire: the report is BOUNDED to what fits in a
+ * pull-request body, and a tally taken off its capped tables would be quietly wrong.
+ */
+export const getPublicRunOutcomeContract = withMinScope('read', defineApiContract({
+    method: 'get',
+    requestPathParamsSchema: runIdParams,
+    pathResolver: ({ runId }) => `/api/v1/runs/${runId}/outcome`,
+    responsesByStatusCode: { 200: runOutcomeSchema, ...errorResponses },
+}));
 /** The binary artifacts the run captured (metadata; the bytes are a second, per-artifact fetch). */
-export const listPublicRunArtifactsContract = defineApiContract({
+export const listPublicRunArtifactsContract = withMinScope('read', defineApiContract({
     method: 'get',
     requestPathParamsSchema: runIdParams,
     pathResolver: ({ runId }) => `/api/v1/runs/${runId}/artifacts`,
     responsesByStatusCode: { 200: publicRunArtifactListSchema, ...errorResponses },
-});
+}));
 //# sourceMappingURL=public-evidence.js.map

package/dist/routes/public-evidence.js.map

@@ -1 +1 @@
-{"version":3,"file":"public-evidence.js","sourceRoot":"","sources":["../../src/routes/public-evidence.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAA;AAC5D,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAEhE,8EAA8E;AAC9E,iFAAiF;AACjF,2FAA2F;AAC3F,yDAAyD;AACzD,EAAE;AACF,6FAA6F;AAC7F,6FAA6F;AAC7F,+FAA+F;AAC/F,gGAAgG;AAChG,0FAA0F;AAC1F,yEAAyE;AACzE,EAAE;AACF,4FAA4F;AAC5F,2FAA2F;AAC3F,gFAAgF;AAChF,8EAA8E;AAE9E,MAAM,WAAW,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAA;AAE9C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,iBAAiB,CAAC;IAC1D,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,WAAW;IACpC,YAAY,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,gBAAgB,KAAK,SAAS;IAC3D,qBAAqB,EAAE,EAAE,GAAG,EAAE,0BAA0B,EAAE,GAAG,cAAc,EAAE;CAC9E,CAAC,CAAA;AAEF,oGAAoG;AACpG,MAAM,CAAC,MAAM,8BAA8B,GAAG,iBAAiB,CAAC;IAC9D,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,WAAW;IACpC,YAAY,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,gBAAgB,KAAK,YAAY;IAC9D,qBAAqB,EAAE,EAAE,GAAG,EAAE,2BAA2B,EAAE,GAAG,cAAc,EAAE;CAC/E,CAAC,CAAA"}
+{"version":3,"file":"public-evidence.js","sourceRoot":"","sources":["../../src/routes/public-evidence.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAA;AAC5D,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAE9E,8EAA8E;AAC9E,iFAAiF;AACjF,2FAA2F;AAC3F,yDAAyD;AACzD,EAAE;AACF,6FAA6F;AAC7F,6FAA6F;AAC7F,+FAA+F;AAC/F,gGAAgG;AAChG,0FAA0F;AAC1F,yEAAyE;AACzE,EAAE;AACF,4FAA4F;AAC5F,2FAA2F;AAC3F,gFAAgF;AAChF,8EAA8E;AAE9E,MAAM,WAAW,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAA;AAE9C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,YAAY,CACpD,MAAM,EACN,iBAAiB,CAAC;IAChB,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,WAAW;IACpC,YAAY,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,gBAAgB,KAAK,SAAS;IAC3D,qBAAqB,EAAE,EAAE,GAAG,EAAE,0BAA0B,EAAE,GAAG,cAAc,EAAE;CAC9E,CAAC,CACH,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,YAAY,CACrD,MAAM,EACN,iBAAiB,CAAC;IAChB,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,WAAW;IACpC,YAAY,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,gBAAgB,KAAK,UAAU;IAC5D,qBAAqB,EAAE,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE;CACpE,CAAC,CACH,CAAA;AAED,oGAAoG;AACpG,MAAM,CAAC,MAAM,8BAA8B,GAAG,YAAY,CACxD,MAAM,EACN,iBAAiB,CAAC;IAChB,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,WAAW;IACpC,YAAY,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,gBAAgB,KAAK,YAAY;IAC9D,qBAAqB,EAAE,EAAE,GAAG,EAAE,2BAA2B,EAAE,GAAG,cAAc,EAAE;CAC/E,CAAC,CACH,CAAA"}

package/dist/routes/spec.d.ts

@@ -73,4 +73,88 @@ export declare const getServiceSpecContract: {
         }, undefined>;
     };
 };
+/**
+ * The spec as ONE RUN was judged against it, read from the branch that run pushed its work to.
+ *
+ * A sibling of {@link getServiceSpecContract} rather than a flag on it, because the two answer
+ * different questions: "what does this service require" (the default branch, the inspector's
+ * requirements window) and "what did this run rule on" (the run's branch, the outcome card). The
+ * SPA's outcome card asked the first and used the answer for the second, so while a pull request
+ * was open every verdict against a requirement the run itself added landed as "not checked".
+ */
+export declare const getRunSpecContract: {
+    readonly method: "get";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        executionId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ executionId }: {
+        executionId: string;
+    }) => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly present: import("valibot").BooleanSchema<undefined>;
+            readonly spec: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                readonly service: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+                readonly summary: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000, undefined>]>, "">;
+                readonly modules: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+                    readonly summary: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000, undefined>]>, "">;
+                    readonly groups: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+                        readonly summary: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000, undefined>]>, "">;
+                        readonly requirements: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                            readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+                            readonly title: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+                            readonly statement: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 4000, undefined>]>;
+                            readonly kind: import("valibot").PicklistSchema<["functional", "nonfunctional", "constraint"], undefined>;
+                            readonly priority: import("valibot").PicklistSchema<["must", "should", "could"], undefined>;
+                            readonly state: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["aspirational", "established"], undefined>, "aspirational">;
+                            readonly sourceBlockIds: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>, undefined>, readonly []>;
+                            readonly acceptance: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                                readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+                                readonly given: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000, undefined>]>;
+                                readonly when: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000, undefined>]>;
+                                readonly outcome: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000, undefined>]>;
+                            }, undefined>, undefined>, readonly []>;
+                        }, undefined>, undefined>, readonly []>;
+                        readonly rules: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                            readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+                            readonly rule: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 4000, undefined>]>;
+                            readonly rationale: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000, undefined>]>, "">;
+                            readonly sourceBlockIds: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>, undefined>, readonly []>;
+                        }, undefined>, undefined>, readonly []>;
+                    }, undefined>, undefined>, readonly []>;
+                }, undefined>, undefined>, readonly []>;
+            }, undefined>, undefined>;
+            readonly features: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly module: import("valibot").StringSchema<undefined>;
+                readonly group: import("valibot").StringSchema<undefined>;
+                readonly path: import("valibot").StringSchema<undefined>;
+                readonly content: import("valibot").StringSchema<undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+};
 //# sourceMappingURL=spec.d.ts.map

package/dist/routes/spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../src/routes/spec.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKjC,CAAA"}
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../src/routes/spec.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKjC,CAAA;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK7B,CAAA"}

package/dist/routes/spec.js

@@ -13,4 +13,19 @@ export const getServiceSpecContract = defineApiContract({
     pathResolver: ({ blockId }) => `/blocks/${blockId}/spec`,
     responsesByStatusCode: { 200: serviceSpecViewSchema, ...errorResponses },
 });
+/**
+ * The spec as ONE RUN was judged against it, read from the branch that run pushed its work to.
+ *
+ * A sibling of {@link getServiceSpecContract} rather than a flag on it, because the two answer
+ * different questions: "what does this service require" (the default branch, the inspector's
+ * requirements window) and "what did this run rule on" (the run's branch, the outcome card). The
+ * SPA's outcome card asked the first and used the answer for the second, so while a pull request
+ * was open every verdict against a requirement the run itself added landed as "not checked".
+ */
+export const getRunSpecContract = defineApiContract({
+    method: 'get',
+    requestPathParamsSchema: singleStringParam('executionId'),
+    pathResolver: ({ executionId }) => `/executions/${executionId}/spec`,
+    responsesByStatusCode: { 200: serviceSpecViewSchema, ...errorResponses },
+});
 //# sourceMappingURL=spec.js.map

package/dist/routes/spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"spec.js","sourceRoot":"","sources":["../../src/routes/spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAClD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAEhE,8EAA8E;AAC9E,iEAAiE;AACjE,kFAAkF;AAClF,4EAA4E;AAC5E,mDAAmD;AACnD,8EAA8E;AAE9E,MAAM,CAAC,MAAM,sBAAsB,GAAG,iBAAiB,CAAC;IACtD,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,iBAAiB,CAAC,SAAS,CAAC;IACrD,YAAY,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,WAAW,OAAO,OAAO;IACxD,qBAAqB,EAAE,EAAE,GAAG,EAAE,qBAAqB,EAAE,GAAG,cAAc,EAAE;CACzE,CAAC,CAAA"}
+{"version":3,"file":"spec.js","sourceRoot":"","sources":["../../src/routes/spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAClD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAEhE,8EAA8E;AAC9E,iEAAiE;AACjE,kFAAkF;AAClF,4EAA4E;AAC5E,mDAAmD;AACnD,8EAA8E;AAE9E,MAAM,CAAC,MAAM,sBAAsB,GAAG,iBAAiB,CAAC;IACtD,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,iBAAiB,CAAC,SAAS,CAAC;IACrD,YAAY,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,WAAW,OAAO,OAAO;IACxD,qBAAqB,EAAE,EAAE,GAAG,EAAE,qBAAqB,EAAE,GAAG,cAAc,EAAE;CACzE,CAAC,CAAA;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;IAClD,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,iBAAiB,CAAC,aAAa,CAAC;IACzD,YAAY,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,eAAe,WAAW,OAAO;IACpE,qBAAqB,EAAE,EAAE,GAAG,EAAE,qBAAqB,EAAE,GAAG,cAAc,EAAE;CACzE,CAAC,CAAA"}

package/dist/run-evidence.d.ts

@@ -0,0 +1,152 @@
+import type { Block } from './entities.js';
+import type { PipelineStep } from './execution.js';
+import type { RequirementPriority, RequirementState, SpecDoc } from './spec.js';
+import type { RequirementVerdict, RequirementVerdictStatus, TestReport } from './testing.js';
+/** The API tester gate's agent kind. */
+export declare 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 declare function isTesterKind(kind: string): boolean;
+/**
+ * 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 declare function selectEvidenceStep(steps: readonly PipelineStep[], matches: (step: PipelineStep) => boolean, hasEvidence: (step: PipelineStep) => boolean): PipelineStep | undefined;
+/** Every tester step of a run, in pipeline order. */
+export declare function testerSteps(steps: readonly PipelineStep[]): PipelineStep[];
+/**
+ * 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 declare function selectTesterReportStep(steps: readonly PipelineStep[]): PipelineStep | undefined;
+/**
+ * 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 declare function indexRequirementVerdicts(steps: readonly PipelineStep[]): Map<string, RequirementVerdict>;
+/**
+ * One spec requirement paired with what the tester observed about it: the REQUIREMENT →
+ * EVIDENCE row both reductions are built from.
+ *
+ * Deliberately un-scrubbed and un-clamped. A consumer writing onto a rendered surface (a pull
+ * request body) owes the text its own boundary treatment, and doing it here would hand the SPA
+ * escaped entities it has no reason to render.
+ */
+export interface JoinedRequirement {
+    /** The spec requirement's stable id: the join key, and what a reader greps `spec/` for. */
+    id: string;
+    title: string;
+    /** Where it lives in the spec taxonomy. */
+    module: string;
+    group: string;
+    priority: RequirementPriority;
+    /**
+     * Implementation state as `spec/` recorded it. It travels WITH the verdict because it is what
+     * makes `not_met` readable: against an `aspirational` requirement that is in-flight work,
+     * against an `established` one it is behaviour the service has lost.
+     */
+    state: RequirementState;
+    /** What the tester observed; `not_covered` when no tester ruled on it. */
+    verdict: RequirementVerdictStatus;
+    /** The tester's evidence for the verdict, when it gave any. */
+    detail: string | null;
+    /** How many acceptance criteria the requirement carries in `spec/`. */
+    criteriaCount: number;
+}
+/**
+ * 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 declare function joinSpecRequirements(spec: SpecDoc, verdicts: ReadonlyMap<string, RequirementVerdict>): JoinedRequirement[];
+/**
+ * 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 declare function unmatchedVerdictIds(rows: readonly JoinedRequirement[], verdicts: ReadonlyMap<string, RequirementVerdict>): string[];
+/**
+ * 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 declare function runSpecBranch(block: Block, defaultBranch: string): string;
+/**
+ * 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 declare function isRequirementRegression(row: {
+    state: RequirementState;
+    verdict: RequirementVerdictStatus;
+}): boolean;
+/** How many requirements landed on each verdict, over the WHOLE join and before any cap. */
+export interface RequirementTally {
+    met: number;
+    notMet: number;
+    notCovered: number;
+    /** A SUBSET of `notMet`: see {@link isRequirementRegression}. */
+    regressions: number;
+    total: number;
+}
+/**
+ * Count a join. Over every row and before any cap, so a surface that shows a bounded table still
+ * reports the true totals.
+ */
+export declare function tallyRequirements(rows: readonly JoinedRequirement[]): RequirementTally;
+/** How the areas a tester exercised came out. */
+export interface TestOutcomeTally {
+    passed: number;
+    failed: number;
+    skipped: number;
+}
+/** Tally a tester report's per-area outcomes. */
+export declare function tallyTestOutcomes(report: TestReport): TestOutcomeTally;
+//# sourceMappingURL=run-evidence.d.ts.map

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

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