peaks-loop 4.1.21 → 4.1.23
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.claude-plugin/marketplace.json +3 -6
- package/CHANGELOG.md +191 -0
- package/dist/cli/commands/mut-commands-helpers.d.ts +6 -6
- package/dist/cli/commands/mut-commands-helpers.js +44 -26
- package/dist/cli/commands/observability-commands-hotspots.d.ts +54 -0
- package/dist/cli/commands/observability-commands-hotspots.js +222 -0
- package/dist/cli/commands/observability-commands-near-miss.d.ts +28 -0
- package/dist/cli/commands/observability-commands-near-miss.js +105 -0
- package/dist/cli/commands/observability-commands-queries.d.ts +61 -18
- package/dist/cli/commands/observability-commands-queries.js +88 -47
- package/dist/cli/commands/observability-commands.js +79 -20
- package/dist/services/artifacts/artifact-prerequisites.d.ts +3 -0
- package/dist/services/artifacts/artifact-prerequisites.js +1 -1
- package/dist/services/artifacts/prerequisite-path-census.d.ts +42 -0
- package/dist/services/artifacts/prerequisite-path-census.js +79 -0
- package/dist/services/artifacts/prerequisite-transition-event.js +13 -1
- package/dist/services/artifacts/rd-gate-event.d.ts +106 -0
- package/dist/services/artifacts/rd-gate-event.js +211 -0
- package/dist/services/artifacts/rd-transition-gates.d.ts +6 -0
- package/dist/services/artifacts/rd-transition-gates.js +65 -24
- package/dist/services/distribution/json-layout.d.ts +20 -0
- package/dist/services/distribution/json-layout.js +195 -0
- package/dist/services/distribution/plugin-manifest.d.ts +31 -2
- package/dist/services/distribution/plugin-manifest.js +40 -4
- package/dist/services/observability/aggregation-types.d.ts +21 -0
- package/dist/services/observability/aggregation.d.ts +12 -2
- package/dist/services/observability/aggregation.js +26 -2
- package/dist/services/observability/compliance-judge.d.ts +77 -0
- package/dist/services/observability/compliance-judge.js +143 -0
- package/dist/services/observability/compliance-spec.d.ts +96 -0
- package/dist/services/observability/compliance-spec.js +29 -0
- package/dist/services/observability/compliance-specs/peaks-race-code.spec.d.ts +37 -0
- package/dist/services/observability/compliance-specs/peaks-race-code.spec.js +66 -0
- package/dist/services/observability/compliance-specs/peaks-rd.spec.d.ts +50 -0
- package/dist/services/observability/compliance-specs/peaks-rd.spec.js +111 -0
- package/dist/services/observability/hotspot-attribution-summary.d.ts +84 -0
- package/dist/services/observability/hotspot-attribution-summary.js +74 -0
- package/dist/services/observability/hotspot-rows.d.ts +47 -0
- package/dist/services/observability/hotspot-rows.js +89 -0
- package/dist/services/observability/hotspot-shared.d.ts +212 -0
- package/dist/services/observability/hotspot-shared.js +122 -0
- package/dist/services/observability/hotspot-sources.d.ts +55 -0
- package/dist/services/observability/hotspot-sources.js +142 -0
- package/dist/services/observability/hotspots.d.ts +47 -0
- package/dist/services/observability/hotspots.js +47 -0
- package/dist/services/observability/near-miss-attempts.d.ts +175 -0
- package/dist/services/observability/near-miss-attempts.js +223 -0
- package/dist/services/observability/near-miss-coverage.d.ts +109 -0
- package/dist/services/observability/near-miss-coverage.js +108 -0
- package/dist/services/observability/near-miss-denominator.d.ts +81 -0
- package/dist/services/observability/near-miss-denominator.js +75 -0
- package/dist/services/observability/near-miss-difference.d.ts +98 -0
- package/dist/services/observability/near-miss-difference.js +132 -0
- package/dist/services/observability/near-miss-facts.d.ts +165 -0
- package/dist/services/observability/near-miss-facts.js +101 -0
- package/dist/services/observability/near-miss-gate-events.d.ts +75 -0
- package/dist/services/observability/near-miss-gate-events.js +106 -0
- package/dist/services/observability/near-miss-gates.d.ts +108 -0
- package/dist/services/observability/near-miss-gates.js +135 -0
- package/dist/services/observability/near-miss-records.d.ts +93 -0
- package/dist/services/observability/near-miss-records.js +87 -0
- package/dist/services/observability/near-miss.d.ts +148 -0
- package/dist/services/observability/near-miss.js +196 -0
- package/dist/services/observability/observability-schema.d.ts +17 -2
- package/dist/services/observability/observability-schema.js +21 -1
- package/dist/services/observability/owner-skill-map.d.ts +92 -0
- package/dist/services/observability/owner-skill-map.js +144 -0
- package/dist/services/observability/report-formatter-hotspots.d.ts +32 -0
- package/dist/services/observability/report-formatter-hotspots.js +76 -0
- package/dist/services/observability/report-formatter-near-miss.d.ts +48 -0
- package/dist/services/observability/report-formatter-near-miss.js +234 -0
- package/dist/services/observability/report-formatter.d.ts +49 -3
- package/dist/services/observability/report-formatter.js +55 -14
- package/dist/services/observability/retro-attribution.d.ts +129 -0
- package/dist/services/observability/retro-attribution.js +134 -0
- package/dist/services/observability/session-metric-rows.d.ts +153 -0
- package/dist/services/observability/session-metric-rows.js +184 -0
- package/package.json +5 -5
|
@@ -0,0 +1,81 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* `src/services/observability/near-miss-denominator.ts`
|
|
3
|
+
*
|
|
4
|
+
* The denominator the near-miss rate divides by, and its reconciliation with
|
|
5
|
+
* the status summary's success count.
|
|
6
|
+
*
|
|
7
|
+
* WHY THIS EXISTS. "Passed" has TWO definitions in this repository, and they
|
|
8
|
+
* do not count the same slices:
|
|
9
|
+
*
|
|
10
|
+
* - the STATUS SUMMARY counts a slice successful when its FINAL state is one
|
|
11
|
+
* of the terminal-happy states (`handed-off`, `verdict-issued`, …);
|
|
12
|
+
* - the NEAR-MISS metric counts a slice passed when it recorded a
|
|
13
|
+
* SUCCESSFUL `verdict-issued` attempt — the attempt whose prereq check
|
|
14
|
+
* passed, which is the moment the slice was declared passing.
|
|
15
|
+
*
|
|
16
|
+
* On this repository's recorded history the status summary counts 103
|
|
17
|
+
* successes and the near-miss denominator holds 94 slices. The gap is REAL
|
|
18
|
+
* and it is not noise, so the output states both numbers and says what the
|
|
19
|
+
* gap is made of. Silently aligning one to the other by fiat would hide the
|
|
20
|
+
* very thing the reader needs to see.
|
|
21
|
+
*
|
|
22
|
+
* WHY THE GAP'S COMPOSITION LIVES NEXT DOOR. Counting what the gap is made
|
|
23
|
+
* of, and naming the cause of each part, is a different question from the one
|
|
24
|
+
* this module answers — and the answer is long enough to need its own file.
|
|
25
|
+
* `near-miss-difference.ts` holds that part.
|
|
26
|
+
*
|
|
27
|
+
* WHY THE ROLLUPS COME FROM THE AGGREGATION. The comparison is only
|
|
28
|
+
* meaningful if the status side is computed by the SAME code the status
|
|
29
|
+
* summary uses, so the reconciliation cannot drift from the number it
|
|
30
|
+
* reconciles with. `aggregateSlices` is that code.
|
|
31
|
+
*
|
|
32
|
+
* WHY THE RECONCILIATION IS A COUNT AND NOT A STORY. Each side of the gap is
|
|
33
|
+
* counted, so a reader can check the arithmetic: the status count, minus the
|
|
34
|
+
* slices it counts that have no pass moment, plus the slices that have a
|
|
35
|
+
* pass moment it does not count, is the near-miss denominator.
|
|
36
|
+
*/
|
|
37
|
+
import { type NearMissDifferenceCounts } from './near-miss-difference.js';
|
|
38
|
+
import type { RequestTypeReading } from './hotspot-shared.js';
|
|
39
|
+
import type { ObservabilityEvent } from './observability-service.js';
|
|
40
|
+
/**
|
|
41
|
+
* The definition of "passed" the near-miss metric divides by, and how it
|
|
42
|
+
* relates to the status summary's success count.
|
|
43
|
+
*/
|
|
44
|
+
export type NearMissDenominator = {
|
|
45
|
+
/** What "passed" means here, in words a reader can check. */
|
|
46
|
+
readonly definition: string;
|
|
47
|
+
/** How many slices that definition admits — the rate's denominator. */
|
|
48
|
+
readonly sliceCount: number;
|
|
49
|
+
/**
|
|
50
|
+
* The status summary's success count over the same events.
|
|
51
|
+
*
|
|
52
|
+
* It is reported even when it AGREES, so a reader who compares the two
|
|
53
|
+
* numbers is never left guessing whether they were compared at all.
|
|
54
|
+
*/
|
|
55
|
+
readonly statusSuccessCount: number;
|
|
56
|
+
/**
|
|
57
|
+
* The slices that are in NEITHER the numerator nor the denominator
|
|
58
|
+
* because their pass verdict could not be read.
|
|
59
|
+
*
|
|
60
|
+
* They are reported so the denominator's composition is visible: a reader
|
|
61
|
+
* who adds up the slices and finds some missing must be able to see WHERE
|
|
62
|
+
* they went rather than infer it.
|
|
63
|
+
*/
|
|
64
|
+
readonly unmeasuredSliceCount: number;
|
|
65
|
+
/** The reconciliation, or null when the two counts agree. */
|
|
66
|
+
readonly difference: NearMissDenominatorDifference | null;
|
|
67
|
+
};
|
|
68
|
+
/** What the gap between the two "passed" definitions is made of. */
|
|
69
|
+
export type NearMissDenominatorDifference = NearMissDifferenceCounts & {
|
|
70
|
+
/** The reconciliation, spelled out. */
|
|
71
|
+
readonly note: string;
|
|
72
|
+
};
|
|
73
|
+
/** The definition, stated once, so the output and the source agree. */
|
|
74
|
+
export declare const PASSED_DEFINITION: string;
|
|
75
|
+
/**
|
|
76
|
+
* The denominator, and its reconciliation with the status summary.
|
|
77
|
+
*
|
|
78
|
+
* The status side comes from the aggregation's own rollup, so the number this
|
|
79
|
+
* reconciles with is the number the status summary reports.
|
|
80
|
+
*/
|
|
81
|
+
export declare function describeDenominator(events: readonly ObservabilityEvent[], sliceCount: number, requestTypes?: ReadonlyMap<string, RequestTypeReading>, unmeasuredSliceCount?: number): NearMissDenominator;
|
|
@@ -0,0 +1,75 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* `src/services/observability/near-miss-denominator.ts`
|
|
3
|
+
*
|
|
4
|
+
* The denominator the near-miss rate divides by, and its reconciliation with
|
|
5
|
+
* the status summary's success count.
|
|
6
|
+
*
|
|
7
|
+
* WHY THIS EXISTS. "Passed" has TWO definitions in this repository, and they
|
|
8
|
+
* do not count the same slices:
|
|
9
|
+
*
|
|
10
|
+
* - the STATUS SUMMARY counts a slice successful when its FINAL state is one
|
|
11
|
+
* of the terminal-happy states (`handed-off`, `verdict-issued`, …);
|
|
12
|
+
* - the NEAR-MISS metric counts a slice passed when it recorded a
|
|
13
|
+
* SUCCESSFUL `verdict-issued` attempt — the attempt whose prereq check
|
|
14
|
+
* passed, which is the moment the slice was declared passing.
|
|
15
|
+
*
|
|
16
|
+
* On this repository's recorded history the status summary counts 103
|
|
17
|
+
* successes and the near-miss denominator holds 94 slices. The gap is REAL
|
|
18
|
+
* and it is not noise, so the output states both numbers and says what the
|
|
19
|
+
* gap is made of. Silently aligning one to the other by fiat would hide the
|
|
20
|
+
* very thing the reader needs to see.
|
|
21
|
+
*
|
|
22
|
+
* WHY THE GAP'S COMPOSITION LIVES NEXT DOOR. Counting what the gap is made
|
|
23
|
+
* of, and naming the cause of each part, is a different question from the one
|
|
24
|
+
* this module answers — and the answer is long enough to need its own file.
|
|
25
|
+
* `near-miss-difference.ts` holds that part.
|
|
26
|
+
*
|
|
27
|
+
* WHY THE ROLLUPS COME FROM THE AGGREGATION. The comparison is only
|
|
28
|
+
* meaningful if the status side is computed by the SAME code the status
|
|
29
|
+
* summary uses, so the reconciliation cannot drift from the number it
|
|
30
|
+
* reconciles with. `aggregateSlices` is that code.
|
|
31
|
+
*
|
|
32
|
+
* WHY THE RECONCILIATION IS A COUNT AND NOT A STORY. Each side of the gap is
|
|
33
|
+
* counted, so a reader can check the arithmetic: the status count, minus the
|
|
34
|
+
* slices it counts that have no pass moment, plus the slices that have a
|
|
35
|
+
* pass moment it does not count, is the near-miss denominator.
|
|
36
|
+
*/
|
|
37
|
+
import { aggregateSlices } from './aggregation.js';
|
|
38
|
+
import { countDifferences, differenceNote } from './near-miss-difference.js';
|
|
39
|
+
/** The definition, stated once, so the output and the source agree. */
|
|
40
|
+
export const PASSED_DEFINITION = 'a slice that recorded a SUCCESSFUL `verdict-issued` attempt — a `verdict-issued` ' +
|
|
41
|
+
'transition attempt whose prereq check passed, which is the moment the slice was ' +
|
|
42
|
+
'declared passing. A `verdict-issued` attempt whose check FAILED is a refused ' +
|
|
43
|
+
'transition, not a pass. A slice whose `verdict-issued` attempt records a prereq ' +
|
|
44
|
+
'verdict this build CANNOT READ is in NEITHER: whether it passed is unknown, so it ' +
|
|
45
|
+
'is reported as unmeasured rather than counted here.';
|
|
46
|
+
/**
|
|
47
|
+
* The denominator, and its reconciliation with the status summary.
|
|
48
|
+
*
|
|
49
|
+
* The status side comes from the aggregation's own rollup, so the number this
|
|
50
|
+
* reconciles with is the number the status summary reports.
|
|
51
|
+
*/
|
|
52
|
+
export function describeDenominator(events, sliceCount, requestTypes = new Map(), unmeasuredSliceCount = 0) {
|
|
53
|
+
const rollups = aggregateSlices(events);
|
|
54
|
+
const statusSuccessCount = rollups.filter((rollup) => rollup.success).length;
|
|
55
|
+
if (statusSuccessCount === sliceCount) {
|
|
56
|
+
return {
|
|
57
|
+
definition: PASSED_DEFINITION,
|
|
58
|
+
sliceCount,
|
|
59
|
+
statusSuccessCount,
|
|
60
|
+
unmeasuredSliceCount,
|
|
61
|
+
difference: null
|
|
62
|
+
};
|
|
63
|
+
}
|
|
64
|
+
const counts = countDifferences(events, rollups, requestTypes);
|
|
65
|
+
return {
|
|
66
|
+
definition: PASSED_DEFINITION,
|
|
67
|
+
sliceCount,
|
|
68
|
+
statusSuccessCount,
|
|
69
|
+
unmeasuredSliceCount,
|
|
70
|
+
difference: {
|
|
71
|
+
...counts,
|
|
72
|
+
note: differenceNote(statusSuccessCount, sliceCount, counts)
|
|
73
|
+
}
|
|
74
|
+
};
|
|
75
|
+
}
|
|
@@ -0,0 +1,98 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* `src/services/observability/near-miss-difference.ts`
|
|
3
|
+
*
|
|
4
|
+
* WHAT THE GAP between the two "passed" definitions is made of.
|
|
5
|
+
*
|
|
6
|
+
* WHY THIS IS ITS OWN MODULE. The reconciliation is a COUNTING question —
|
|
7
|
+
* each side of the gap is counted so a reader can check the arithmetic — and
|
|
8
|
+
* it is a different question from the one the denominator answers. Keeping
|
|
9
|
+
* them apart is what lets the denominator stay the short statement of "what
|
|
10
|
+
* this count means" and lets this module be the long statement of "why the
|
|
11
|
+
* two counts differ".
|
|
12
|
+
*
|
|
13
|
+
* WHY THE NOTE NAMES A CAUSE RATHER THAN A MISSING TRACE. Seventeen of the
|
|
14
|
+
* gap slices recorded no successful verdict attempt, and seven of those
|
|
15
|
+
* reached a `verdict-issued` event with no prereq verdict beside it. It is
|
|
16
|
+
* tempting to read that as "the check ran and left no record" — but it is
|
|
17
|
+
* not what happened, and saying so would send a reader hunting for an
|
|
18
|
+
* emitter bug that does not exist. The prereq check RETURNS EARLY when the
|
|
19
|
+
* request type's table has no row for the transition being checked, before
|
|
20
|
+
* it emits anything. The `docs` and `chore` types use a minimal table with
|
|
21
|
+
* no `qa:verdict-issued` row, so that transition has NO prerequisite to
|
|
22
|
+
* verify it against and the check has nothing to record. The pass was never
|
|
23
|
+
* gated, rather than gated-and-unrecorded.
|
|
24
|
+
*
|
|
25
|
+
* WHY AN UNREADABLE VERDICT IS COUNTED APART. A `verdict-issued` attempt
|
|
26
|
+
* whose prereq verdict was RECORDED in a shape this build cannot read is a
|
|
27
|
+
* different cause from one that was never recorded: the second was never
|
|
28
|
+
* gated, the first was gated and its verdict is unreadable. Folding them
|
|
29
|
+
* together would attribute an unreadable verdict to a missing prerequisite
|
|
30
|
+
* row, which is a cause the record does not support.
|
|
31
|
+
*/
|
|
32
|
+
import { type RequestType } from '../artifacts/artifact-prerequisites.js';
|
|
33
|
+
import type { SliceRollup } from './aggregation.js';
|
|
34
|
+
import type { RequestTypeReading } from './hotspot-shared.js';
|
|
35
|
+
import type { ObservabilityEvent } from './observability-service.js';
|
|
36
|
+
/** The counts that make the gap up, and the note that spells them out. */
|
|
37
|
+
export type NearMissDifferenceCounts = {
|
|
38
|
+
/**
|
|
39
|
+
* Slices the status summary counts as successful that recorded no
|
|
40
|
+
* successful verdict attempt.
|
|
41
|
+
*/
|
|
42
|
+
readonly successWithoutPassMoment: number;
|
|
43
|
+
/**
|
|
44
|
+
* Of those, the ones that reached a `verdict-issued` EVENT whose prereq
|
|
45
|
+
* verdict was never recorded.
|
|
46
|
+
*/
|
|
47
|
+
readonly successWithoutPassMomentButReachedVerdict: number;
|
|
48
|
+
/**
|
|
49
|
+
* Of those, the ones whose `verdict-issued` attempt recorded a prereq
|
|
50
|
+
* verdict that could not be READ.
|
|
51
|
+
*/
|
|
52
|
+
readonly successWithoutPassMomentButUnreadableVerdict: number;
|
|
53
|
+
/**
|
|
54
|
+
* The request types whose slices recorded no successful verdict attempt.
|
|
55
|
+
*
|
|
56
|
+
* WHY THIS IS THE CAUSE, NOT A SYMPTOM. The prereq event is emitted by the
|
|
57
|
+
* prerequisite check, and the check RETURNS EARLY when the request type's
|
|
58
|
+
* table has no row for the transition being checked — so no event is
|
|
59
|
+
* emitted at all. The `docs` and `chore` types use a minimal table with no
|
|
60
|
+
* `qa:verdict-issued` row, so the verdict transition has NO prerequisite to
|
|
61
|
+
* verify it against and the check has nothing to record.
|
|
62
|
+
*
|
|
63
|
+
* So the pass was not "unverified" — it was never gated, because there was
|
|
64
|
+
* no gate there. Saying "the check left no trace" would send a reader
|
|
65
|
+
* hunting for an emitter bug that does not exist.
|
|
66
|
+
*/
|
|
67
|
+
readonly typesWithoutVerdictPrerequisite: readonly RequestType[];
|
|
68
|
+
/**
|
|
69
|
+
* The slices of those types — the concrete referents for the count.
|
|
70
|
+
*/
|
|
71
|
+
readonly slicesWithoutVerdictPrerequisite: readonly string[];
|
|
72
|
+
/**
|
|
73
|
+
* Slices that recorded a successful verdict attempt but the status summary
|
|
74
|
+
* does not count as successful — they were sent back for rework after the
|
|
75
|
+
* verdict, so their final state is not a terminal-happy one.
|
|
76
|
+
*/
|
|
77
|
+
readonly passMomentWithoutStatusSuccess: number;
|
|
78
|
+
};
|
|
79
|
+
/**
|
|
80
|
+
* The counts that make the gap between the two "passed" definitions up.
|
|
81
|
+
*
|
|
82
|
+
* Each side of the gap is counted, so a reader can check the arithmetic: the
|
|
83
|
+
* status count, minus the slices it counts that have no pass moment, plus the
|
|
84
|
+
* slices that have a pass moment it does not count, is the near-miss
|
|
85
|
+
* denominator.
|
|
86
|
+
*/
|
|
87
|
+
export declare function countDifferences(events: readonly ObservabilityEvent[], rollups: readonly SliceRollup[], requestTypes: ReadonlyMap<string, RequestTypeReading>): NearMissDifferenceCounts;
|
|
88
|
+
/**
|
|
89
|
+
* The reconciliation, in words.
|
|
90
|
+
*
|
|
91
|
+
* WHY IT NAMES THE CAUSE. The slices that reached a `verdict-issued` event
|
|
92
|
+
* with no recorded prereq verdict were NOT "unverified" — the request types
|
|
93
|
+
* they had have no `qa:verdict-issued` prerequisite row at all, so the
|
|
94
|
+
* transition had no check to verify it against and the check had nothing to
|
|
95
|
+
* record. Saying the check "left no trace" would send a reader hunting for
|
|
96
|
+
* an emitter bug that does not exist.
|
|
97
|
+
*/
|
|
98
|
+
export declare function differenceNote(statusSuccessCount: number, sliceCount: number, counts: NearMissDifferenceCounts): string;
|
|
@@ -0,0 +1,132 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* `src/services/observability/near-miss-difference.ts`
|
|
3
|
+
*
|
|
4
|
+
* WHAT THE GAP between the two "passed" definitions is made of.
|
|
5
|
+
*
|
|
6
|
+
* WHY THIS IS ITS OWN MODULE. The reconciliation is a COUNTING question —
|
|
7
|
+
* each side of the gap is counted so a reader can check the arithmetic — and
|
|
8
|
+
* it is a different question from the one the denominator answers. Keeping
|
|
9
|
+
* them apart is what lets the denominator stay the short statement of "what
|
|
10
|
+
* this count means" and lets this module be the long statement of "why the
|
|
11
|
+
* two counts differ".
|
|
12
|
+
*
|
|
13
|
+
* WHY THE NOTE NAMES A CAUSE RATHER THAN A MISSING TRACE. Seventeen of the
|
|
14
|
+
* gap slices recorded no successful verdict attempt, and seven of those
|
|
15
|
+
* reached a `verdict-issued` event with no prereq verdict beside it. It is
|
|
16
|
+
* tempting to read that as "the check ran and left no record" — but it is
|
|
17
|
+
* not what happened, and saying so would send a reader hunting for an
|
|
18
|
+
* emitter bug that does not exist. The prereq check RETURNS EARLY when the
|
|
19
|
+
* request type's table has no row for the transition being checked, before
|
|
20
|
+
* it emits anything. The `docs` and `chore` types use a minimal table with
|
|
21
|
+
* no `qa:verdict-issued` row, so that transition has NO prerequisite to
|
|
22
|
+
* verify it against and the check has nothing to record. The pass was never
|
|
23
|
+
* gated, rather than gated-and-unrecorded.
|
|
24
|
+
*
|
|
25
|
+
* WHY AN UNREADABLE VERDICT IS COUNTED APART. A `verdict-issued` attempt
|
|
26
|
+
* whose prereq verdict was RECORDED in a shape this build cannot read is a
|
|
27
|
+
* different cause from one that was never recorded: the second was never
|
|
28
|
+
* gated, the first was gated and its verdict is unreadable. Folding them
|
|
29
|
+
* together would attribute an unreadable verdict to a missing prerequisite
|
|
30
|
+
* row, which is a cause the record does not support.
|
|
31
|
+
*/
|
|
32
|
+
import { collectAttempts, passMomentOf, unreadableVerdictOf, VERDICT_STATE } from './near-miss-attempts.js';
|
|
33
|
+
import { getPrerequisitesFor } from '../artifacts/artifact-prerequisites.js';
|
|
34
|
+
/**
|
|
35
|
+
* Whether a request type's prerequisite table has a row for the verdict
|
|
36
|
+
* transition.
|
|
37
|
+
*
|
|
38
|
+
* The prereq check RETURNS EARLY when the table has no row for the
|
|
39
|
+
* transition being checked — before it emits anything — so a type with no
|
|
40
|
+
* `qa:verdict-issued` row has no event to record for that transition. The
|
|
41
|
+
* `docs` and `chore` types use a minimal table with no such row.
|
|
42
|
+
*/
|
|
43
|
+
function hasVerdictPrerequisite(type) {
|
|
44
|
+
return getPrerequisitesFor('qa', 'verdict-issued', type).length > 0;
|
|
45
|
+
}
|
|
46
|
+
/**
|
|
47
|
+
* The counts that make the gap between the two "passed" definitions up.
|
|
48
|
+
*
|
|
49
|
+
* Each side of the gap is counted, so a reader can check the arithmetic: the
|
|
50
|
+
* status count, minus the slices it counts that have no pass moment, plus the
|
|
51
|
+
* slices that have a pass moment it does not count, is the near-miss
|
|
52
|
+
* denominator.
|
|
53
|
+
*/
|
|
54
|
+
export function countDifferences(events, rollups, requestTypes) {
|
|
55
|
+
let successWithoutPassMoment = 0;
|
|
56
|
+
let successWithoutPassMomentButReachedVerdict = 0;
|
|
57
|
+
let successWithoutPassMomentButUnreadableVerdict = 0;
|
|
58
|
+
let passMomentWithoutStatusSuccess = 0;
|
|
59
|
+
const types = new Set();
|
|
60
|
+
const slices = [];
|
|
61
|
+
for (const rollup of rollups) {
|
|
62
|
+
const sliceEvents = events.filter((event) => event.category === 'slice-transition' && event.sliceRid === rollup.sliceRid);
|
|
63
|
+
const attempts = collectAttempts(sliceEvents);
|
|
64
|
+
const hasPassMoment = passMomentOf(attempts) !== null;
|
|
65
|
+
if (rollup.success && !hasPassMoment) {
|
|
66
|
+
successWithoutPassMoment += 1;
|
|
67
|
+
const reachedVerdict = sliceEvents.some((event) => event.detail.to === VERDICT_STATE);
|
|
68
|
+
if (reachedVerdict) {
|
|
69
|
+
// A verdict that was RECORDED but cannot be READ is a different
|
|
70
|
+
// cause from one that was never recorded, so it is counted apart.
|
|
71
|
+
if (unreadableVerdictOf(sliceEvents) !== null) {
|
|
72
|
+
successWithoutPassMomentButUnreadableVerdict += 1;
|
|
73
|
+
}
|
|
74
|
+
else {
|
|
75
|
+
successWithoutPassMomentButReachedVerdict += 1;
|
|
76
|
+
const reading = requestTypes.get(rollup.sliceRid);
|
|
77
|
+
// The cause: the type's prerequisite table has NO row for the
|
|
78
|
+
// `qa -> verdict-issued` transition, so the check had nothing to
|
|
79
|
+
// verify and emitted no event. The pass was never gated, rather
|
|
80
|
+
// than gated-and-unrecorded.
|
|
81
|
+
if (reading !== undefined && !hasVerdictPrerequisite(reading.requestType)) {
|
|
82
|
+
types.add(reading.requestType);
|
|
83
|
+
slices.push(rollup.sliceRid);
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
}
|
|
87
|
+
}
|
|
88
|
+
if (!rollup.success && hasPassMoment)
|
|
89
|
+
passMomentWithoutStatusSuccess += 1;
|
|
90
|
+
}
|
|
91
|
+
return {
|
|
92
|
+
successWithoutPassMoment,
|
|
93
|
+
successWithoutPassMomentButReachedVerdict,
|
|
94
|
+
successWithoutPassMomentButUnreadableVerdict,
|
|
95
|
+
typesWithoutVerdictPrerequisite: [...types].sort(),
|
|
96
|
+
slicesWithoutVerdictPrerequisite: slices.sort(),
|
|
97
|
+
passMomentWithoutStatusSuccess
|
|
98
|
+
};
|
|
99
|
+
}
|
|
100
|
+
/**
|
|
101
|
+
* The reconciliation, in words.
|
|
102
|
+
*
|
|
103
|
+
* WHY IT NAMES THE CAUSE. The slices that reached a `verdict-issued` event
|
|
104
|
+
* with no recorded prereq verdict were NOT "unverified" — the request types
|
|
105
|
+
* they had have no `qa:verdict-issued` prerequisite row at all, so the
|
|
106
|
+
* transition had no check to verify it against and the check had nothing to
|
|
107
|
+
* record. Saying the check "left no trace" would send a reader hunting for
|
|
108
|
+
* an emitter bug that does not exist.
|
|
109
|
+
*/
|
|
110
|
+
export function differenceNote(statusSuccessCount, sliceCount, counts) {
|
|
111
|
+
const base = `The status summary counts ${statusSuccessCount} slices successful (final state is a ` +
|
|
112
|
+
`terminal-happy state); this metric counts ${sliceCount} passed (a successful ` +
|
|
113
|
+
`\`verdict-issued\` attempt). The gap is ${counts.successWithoutPassMoment} slice(s) the ` +
|
|
114
|
+
'status counts successful with no successful verdict attempt';
|
|
115
|
+
const cause = counts.typesWithoutVerdictPrerequisite.length === 0
|
|
116
|
+
? ` — ${counts.successWithoutPassMomentButReachedVerdict} of which reached a ` +
|
|
117
|
+
'`verdict-issued` event whose prereq verdict was never recorded'
|
|
118
|
+
: ` — ${counts.successWithoutPassMomentButReachedVerdict} of which reached a ` +
|
|
119
|
+
'`verdict-issued` event whose prereq verdict was never recorded, because their ' +
|
|
120
|
+
`request type(s) ${counts.typesWithoutVerdictPrerequisite.map((type) => `\`${type}\``).join(', ')} ` +
|
|
121
|
+
'have NO `qa:verdict-issued` prerequisite row: the transition had no check to verify ' +
|
|
122
|
+
'it against, so the check had nothing to record. The pass was never gated, rather than ' +
|
|
123
|
+
'gated-and-unrecorded';
|
|
124
|
+
const unreadable = counts.successWithoutPassMomentButUnreadableVerdict === 0
|
|
125
|
+
? ''
|
|
126
|
+
: ` — and ${counts.successWithoutPassMomentButUnreadableVerdict} of which recorded a ` +
|
|
127
|
+
'`verdict-issued` attempt whose prereq verdict could not be READ, so they are reported ' +
|
|
128
|
+
'as unmeasured rather than as never gated';
|
|
129
|
+
const rework = ` — less ${counts.passMomentWithoutStatusSuccess} slice(s) that did pass but were sent ` +
|
|
130
|
+
'back for rework afterwards, so their final state is not a terminal-happy one.';
|
|
131
|
+
return `${base}${cause}${unreadable}${rework}`;
|
|
132
|
+
}
|
|
@@ -0,0 +1,165 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* `src/services/observability/near-miss-facts.ts`
|
|
3
|
+
*
|
|
4
|
+
* The event-stream readers the near-miss metric is computed from: what one
|
|
5
|
+
* slice's events say about the gates that were live, the gates that were
|
|
6
|
+
* evaluated, when the slice was declared PASSING, what its prerequisite
|
|
7
|
+
* attempts recorded, and what the slice could be OBSERVED for at all.
|
|
8
|
+
*
|
|
9
|
+
* WHY THIS IS A SEPARATE MODULE. The near-miss metric reads the observability
|
|
10
|
+
* stream the same way the slice aggregation does — the same event shapes, the
|
|
11
|
+
* same terminal-state vocabulary — and those readers are what this module
|
|
12
|
+
* holds, so `near-miss.ts` holds the METRIC and nothing else. The split
|
|
13
|
+
* follows the precedent in this directory: `aggregation.ts` reads the same
|
|
14
|
+
* stream and keeps its readers in `aggregation-helpers.ts` for the same
|
|
15
|
+
* reason.
|
|
16
|
+
*
|
|
17
|
+
* WHY THE READERS ARE CAREFUL ABOUT WHICH EVENT SAYS WHAT. The stream holds
|
|
18
|
+
* two shapes of `slice-transition` event and they mean different things:
|
|
19
|
+
*
|
|
20
|
+
* - the PREREQ shape (`{artifactRole, to, prereqOk, missingCount}`) is
|
|
21
|
+
* emitted by the prerequisite check itself, BEFORE the transition is
|
|
22
|
+
* allowed to proceed. A `prereqOk: false` on it records a REFUSAL: the
|
|
23
|
+
* gate did its job and the transition did not happen.
|
|
24
|
+
* - the TRANSITION shape (`{from, to, artifactRole}`) is emitted after the
|
|
25
|
+
* artifact was written, so it records an ARRIVAL at that state.
|
|
26
|
+
*
|
|
27
|
+
* A reader that treats the prereq shape's `to` as an arrival would count a
|
|
28
|
+
* blocked transition as a slice that got there. The attempts module reads the
|
|
29
|
+
* prereq shape, and the shape that carries no verdict at all is ignored.
|
|
30
|
+
*
|
|
31
|
+
* WHY THE GATE READERS LIVE NEXT DOOR TOO. A gate is identified by a gate id
|
|
32
|
+
* and a phase, and a prerequisite by a transition key — different
|
|
33
|
+
* vocabularies, so `near-miss-gates.ts` holds the gate side.
|
|
34
|
+
*/
|
|
35
|
+
import { type NearMissUndetermined } from './near-miss-gates.js';
|
|
36
|
+
import { type PrereqAttempt, type UnreadableVerdict, type UnsatisfiedKeyState } from './near-miss-attempts.js';
|
|
37
|
+
import type { RdGateId } from '../artifacts/rd-gate-event.js';
|
|
38
|
+
import type { ObservabilityEvent } from './observability-service.js';
|
|
39
|
+
export { KNOWN_GATE_IDS, type NearMissUndetermined } from './near-miss-gates.js';
|
|
40
|
+
/** The event category a tool trace carries once that slice lands. */
|
|
41
|
+
export declare const TOOL_TRACE_CATEGORY = "tool-trace";
|
|
42
|
+
/** Why a slice counts as a near-miss. */
|
|
43
|
+
export type NearMissReason = 'gate-never-evaluated' | 'tool-blocked' | 'prereq-skipped';
|
|
44
|
+
/** A pointer at one raw event, so a reader can check a count against it. */
|
|
45
|
+
export type NearMissEvidence = {
|
|
46
|
+
readonly sessionId: string;
|
|
47
|
+
readonly ts: string;
|
|
48
|
+
/** The gate this event is about, when it is a gate decision. */
|
|
49
|
+
readonly gateId?: string;
|
|
50
|
+
/**
|
|
51
|
+
* The transition key a prereq refusal belongs to, when it is one.
|
|
52
|
+
*
|
|
53
|
+
* The key names WHICH check refused, so a reader can check the pairing: the
|
|
54
|
+
* same key is where a later success would have to appear for the refusal
|
|
55
|
+
* to have been answered.
|
|
56
|
+
*/
|
|
57
|
+
readonly transitionKey?: string;
|
|
58
|
+
};
|
|
59
|
+
/**
|
|
60
|
+
* The state of one transition key AT THE PASS MOMENT.
|
|
61
|
+
*
|
|
62
|
+
* WHY THE STATE IS NOT ONE THING. "The check was unsatisfied" covers two
|
|
63
|
+
* materially different situations, and a reader has to be able to tell them
|
|
64
|
+
* apart:
|
|
65
|
+
*
|
|
66
|
+
* - `refused` — the check WAS run at the pass moment and said no. The gate
|
|
67
|
+
* was live, it fired, and the slice passed anyway.
|
|
68
|
+
* - `unattempted` — the check had NOT been run at the pass moment at all.
|
|
69
|
+
* The role that owns the check had not yet attempted its transition.
|
|
70
|
+
*
|
|
71
|
+
* On this repository's recorded history one of the twelve findings is
|
|
72
|
+
* `refused` and eleven are `unattempted` — and the second is the more alarming
|
|
73
|
+
* of the two, because it means the pass was declared before the owning role
|
|
74
|
+
* had even tried. Calling all twelve "still refusing" would send a reader
|
|
75
|
+
* hunting for a gate that was firing when it was not.
|
|
76
|
+
*/
|
|
77
|
+
export type { UnsatisfiedKeyState } from './near-miss-attempts.js';
|
|
78
|
+
/** One transition key that was unsatisfied when the slice was declared passing. */
|
|
79
|
+
export type UnsatisfiedKey = {
|
|
80
|
+
/** The transition key: `artifactRole -> to`. */
|
|
81
|
+
readonly key: string;
|
|
82
|
+
/** The state of that key's check AT THE PASS MOMENT. */
|
|
83
|
+
readonly state: UnsatisfiedKeyState;
|
|
84
|
+
/** How many times the check refused, whenever it ran. */
|
|
85
|
+
readonly refusalCount: number;
|
|
86
|
+
};
|
|
87
|
+
/**
|
|
88
|
+
* The moment the slice was declared passing, and what was still unsatisfied
|
|
89
|
+
* at that moment.
|
|
90
|
+
*/
|
|
91
|
+
export type PassMoment = {
|
|
92
|
+
/** The position of the successful verdict attempt in the slice's stream. */
|
|
93
|
+
readonly index: number;
|
|
94
|
+
/** The instant of the successful verdict attempt. */
|
|
95
|
+
readonly ts: string;
|
|
96
|
+
/**
|
|
97
|
+
* The transition keys whose check was still unsatisfied when the slice was
|
|
98
|
+
* declared passing, each with its state at that moment.
|
|
99
|
+
*/
|
|
100
|
+
readonly unsatisfiedKeys: readonly UnsatisfiedKey[];
|
|
101
|
+
/** The failed attempts of those keys — the evidence for the finding. */
|
|
102
|
+
readonly failures: readonly PrereqAttempt[];
|
|
103
|
+
};
|
|
104
|
+
/** What one slice's events say about it. */
|
|
105
|
+
export type SliceFacts = {
|
|
106
|
+
readonly sliceRid: string;
|
|
107
|
+
/**
|
|
108
|
+
* The moment the slice was declared PASSING, or null when it never was.
|
|
109
|
+
*
|
|
110
|
+
* A slice with no pass moment is not in the metric's denominator: it was
|
|
111
|
+
* never declared passing, so there is no pass to have been bought by
|
|
112
|
+
* skipping a check.
|
|
113
|
+
*/
|
|
114
|
+
readonly passMoment: PassMoment | null;
|
|
115
|
+
/** The gate ids that were live at some transition of this slice. */
|
|
116
|
+
readonly liveGates: ReadonlySet<RdGateId>;
|
|
117
|
+
/** The gate ids that got a `pass` or a `block` — i.e. WERE evaluated. */
|
|
118
|
+
readonly evaluatedGates: ReadonlySet<RdGateId>;
|
|
119
|
+
/**
|
|
120
|
+
* The gate ids whose VERDICT could not be read.
|
|
121
|
+
*
|
|
122
|
+
* A verdict this build cannot read is not an absent one: the event named an
|
|
123
|
+
* outcome or a gate id this build does not know. Those gates are not
|
|
124
|
+
* reported as never evaluated — they are reported as undetermined.
|
|
125
|
+
*
|
|
126
|
+
* The scope is settled over the WHOLE slice's gate events, not one event at
|
|
127
|
+
* a time: an event this build cannot attribute to a gate may have been the
|
|
128
|
+
* verdict of a gate that recorded nothing of its own, and of no other.
|
|
129
|
+
*/
|
|
130
|
+
readonly unreadableGates: ReadonlySet<RdGateId>;
|
|
131
|
+
/** Whether a tool trace blocked on this slice. */
|
|
132
|
+
readonly toolBlocked: boolean;
|
|
133
|
+
/**
|
|
134
|
+
* The `verdict-issued` attempt whose prereq verdict could not be READ.
|
|
135
|
+
*
|
|
136
|
+
* A slice with one of these has no readable pass moment, and it is neither
|
|
137
|
+
* a pass nor a non-pass: whether it passed is unknown. It is reported as
|
|
138
|
+
* unmeasured rather than dropped, so it cannot read as "no passing slices".
|
|
139
|
+
*/
|
|
140
|
+
readonly unreadableVerdict: UnreadableVerdict | null;
|
|
141
|
+
/** The gates whose liveness the stream did not decide. */
|
|
142
|
+
readonly undetermined: readonly NearMissUndetermined[];
|
|
143
|
+
/**
|
|
144
|
+
* What this slice could be OBSERVED for — the evidence each reason class
|
|
145
|
+
* needs, and whether this slice produced any.
|
|
146
|
+
*
|
|
147
|
+
* A slice that produced no gate event cannot be judged on the gate class at
|
|
148
|
+
* all: the live set is the union over the slice's gate events, so with none
|
|
149
|
+
* the union is empty. The same holds for a slice with no prereq attempt
|
|
150
|
+
* and a slice with no tool trace.
|
|
151
|
+
*/
|
|
152
|
+
readonly observed: {
|
|
153
|
+
readonly gateEvents: number;
|
|
154
|
+
readonly prereqAttempts: number;
|
|
155
|
+
readonly toolTraces: number;
|
|
156
|
+
};
|
|
157
|
+
};
|
|
158
|
+
/**
|
|
159
|
+
* The facts one slice's events carry.
|
|
160
|
+
*
|
|
161
|
+
* The live set is the union over the slice's gate events of the gates that
|
|
162
|
+
* were live at each event's transition — the union is the whole point, so
|
|
163
|
+
* this walks every gate event rather than the last one.
|
|
164
|
+
*/
|
|
165
|
+
export declare function sliceFacts(sliceRid: string, events: readonly ObservabilityEvent[]): SliceFacts;
|
|
@@ -0,0 +1,101 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* `src/services/observability/near-miss-facts.ts`
|
|
3
|
+
*
|
|
4
|
+
* The event-stream readers the near-miss metric is computed from: what one
|
|
5
|
+
* slice's events say about the gates that were live, the gates that were
|
|
6
|
+
* evaluated, when the slice was declared PASSING, what its prerequisite
|
|
7
|
+
* attempts recorded, and what the slice could be OBSERVED for at all.
|
|
8
|
+
*
|
|
9
|
+
* WHY THIS IS A SEPARATE MODULE. The near-miss metric reads the observability
|
|
10
|
+
* stream the same way the slice aggregation does — the same event shapes, the
|
|
11
|
+
* same terminal-state vocabulary — and those readers are what this module
|
|
12
|
+
* holds, so `near-miss.ts` holds the METRIC and nothing else. The split
|
|
13
|
+
* follows the precedent in this directory: `aggregation.ts` reads the same
|
|
14
|
+
* stream and keeps its readers in `aggregation-helpers.ts` for the same
|
|
15
|
+
* reason.
|
|
16
|
+
*
|
|
17
|
+
* WHY THE READERS ARE CAREFUL ABOUT WHICH EVENT SAYS WHAT. The stream holds
|
|
18
|
+
* two shapes of `slice-transition` event and they mean different things:
|
|
19
|
+
*
|
|
20
|
+
* - the PREREQ shape (`{artifactRole, to, prereqOk, missingCount}`) is
|
|
21
|
+
* emitted by the prerequisite check itself, BEFORE the transition is
|
|
22
|
+
* allowed to proceed. A `prereqOk: false` on it records a REFUSAL: the
|
|
23
|
+
* gate did its job and the transition did not happen.
|
|
24
|
+
* - the TRANSITION shape (`{from, to, artifactRole}`) is emitted after the
|
|
25
|
+
* artifact was written, so it records an ARRIVAL at that state.
|
|
26
|
+
*
|
|
27
|
+
* A reader that treats the prereq shape's `to` as an arrival would count a
|
|
28
|
+
* blocked transition as a slice that got there. The attempts module reads the
|
|
29
|
+
* prereq shape, and the shape that carries no verdict at all is ignored.
|
|
30
|
+
*
|
|
31
|
+
* WHY THE GATE READERS LIVE NEXT DOOR TOO. A gate is identified by a gate id
|
|
32
|
+
* and a phase, and a prerequisite by a transition key — different
|
|
33
|
+
* vocabularies, so `near-miss-gates.ts` holds the gate side.
|
|
34
|
+
*/
|
|
35
|
+
import { readGate, unreadableGateIds } from './near-miss-gates.js';
|
|
36
|
+
import { collectAttempts, failuresOf, passMomentOf, unreadableVerdictOf, unsatisfiedKeys } from './near-miss-attempts.js';
|
|
37
|
+
export { KNOWN_GATE_IDS } from './near-miss-gates.js';
|
|
38
|
+
/** The event category a tool trace carries once that slice lands. */
|
|
39
|
+
export const TOOL_TRACE_CATEGORY = 'tool-trace';
|
|
40
|
+
/** Fold one tool-trace event into the accumulator. */
|
|
41
|
+
function readToolTrace(acc, event) {
|
|
42
|
+
// The tool-trace category is not in the schema yet, so this branch finds
|
|
43
|
+
// nothing today. It is written now so that the reason starts firing the
|
|
44
|
+
// moment the category lands. The category is compared as a raw string
|
|
45
|
+
// because the schema's own union does not name it yet, and narrowing the
|
|
46
|
+
// comparison to that union would make this branch uncallable.
|
|
47
|
+
const detail = event.detail;
|
|
48
|
+
acc.toolTraces += 1;
|
|
49
|
+
if (detail.outcome === 'block')
|
|
50
|
+
acc.toolBlocked = true;
|
|
51
|
+
}
|
|
52
|
+
/**
|
|
53
|
+
* The facts one slice's events carry.
|
|
54
|
+
*
|
|
55
|
+
* The live set is the union over the slice's gate events of the gates that
|
|
56
|
+
* were live at each event's transition — the union is the whole point, so
|
|
57
|
+
* this walks every gate event rather than the last one.
|
|
58
|
+
*/
|
|
59
|
+
export function sliceFacts(sliceRid, events) {
|
|
60
|
+
const gateEvents = events.filter((event) => event.category === 'gate');
|
|
61
|
+
const attempts = collectAttempts(events);
|
|
62
|
+
const gates = {
|
|
63
|
+
liveGates: new Set(),
|
|
64
|
+
evaluatedGates: new Set(),
|
|
65
|
+
namedGates: new Set(),
|
|
66
|
+
unattributedGates: new Set(),
|
|
67
|
+
unreadableGates: new Set(),
|
|
68
|
+
undetermined: []
|
|
69
|
+
};
|
|
70
|
+
const acc = { gates, toolBlocked: false, toolTraces: 0 };
|
|
71
|
+
for (const event of events) {
|
|
72
|
+
if (event.category === TOOL_TRACE_CATEGORY)
|
|
73
|
+
readToolTrace(acc, event);
|
|
74
|
+
else if (event.category === 'gate')
|
|
75
|
+
readGate(gates, event, sliceRid, gateEvents);
|
|
76
|
+
}
|
|
77
|
+
const moment = passMomentOf(attempts);
|
|
78
|
+
const unsatisfied = moment === null ? [] : unsatisfiedKeys(attempts, moment.index);
|
|
79
|
+
const failures = unsatisfied.flatMap((entry) => failuresOf(attempts, entry.key));
|
|
80
|
+
return {
|
|
81
|
+
sliceRid,
|
|
82
|
+
passMoment: moment === null
|
|
83
|
+
? null
|
|
84
|
+
: { index: moment.index, ts: moment.ts, unsatisfiedKeys: unsatisfied, failures },
|
|
85
|
+
liveGates: gates.liveGates,
|
|
86
|
+
evaluatedGates: gates.evaluatedGates,
|
|
87
|
+
unreadableGates: unreadableGateIds(gates),
|
|
88
|
+
toolBlocked: acc.toolBlocked,
|
|
89
|
+
// The reference moment is the FIRST successful `verdict-issued` attempt,
|
|
90
|
+
// so an unreadable attempt only unsettles the slice's verdict when it
|
|
91
|
+
// comes at or before that moment. With no moment at all, any unreadable
|
|
92
|
+
// attempt leaves the question open.
|
|
93
|
+
unreadableVerdict: unreadableVerdictOf(events, moment?.index),
|
|
94
|
+
undetermined: gates.undetermined,
|
|
95
|
+
observed: {
|
|
96
|
+
gateEvents: gateEvents.length,
|
|
97
|
+
prereqAttempts: attempts.length,
|
|
98
|
+
toolTraces: acc.toolTraces
|
|
99
|
+
}
|
|
100
|
+
};
|
|
101
|
+
}
|