@dailephd/my-dev-kit-lab 0.4.3 → 0.4.4

package/README.md

@@ -4,7 +4,7 @@ my-dev-kit-lab is the experiment, audit, and evidence companion for [my-dev-kit]
 
 my-dev-kit provides local repository indexing and graph-guided retrieval. my-dev-kit-lab supplies the controlled benchmarks, agent adapters, metrics, security checks, and reports needed to evaluate when that retrieval is useful. Results are evidence for a specific target and configuration; they do not guarantee token savings or security.
 
-The latest published release is v0.4.3 (stage-specific bounded-context and workflow-instruction evaluation). See [docs/CURRENT_STATE.md](docs/CURRENT_STATE.md).
+The latest published release is v0.4.4 (producer-readiness bridge). See [docs/CURRENT_STATE.md](docs/CURRENT_STATE.md).
 
 ## Current capabilities
 
@@ -14,6 +14,7 @@ The latest published release is v0.4.3 (stage-specific bounded-context and workf
 - **Validate Android projects:** run nineteen static checks by default, with Gradle operations, external tools, and network access available only through explicit opt-in flags.
 - **Review evidence:** generate JSON and HTML reports, SVG plots, optional screenshots, visualization demos, and a static gallery.
 - **Evaluate stage-context strategies:** compare the two legacy strategies against six additional bounded stage-context strategies — `architecture-context-only`, `architecture-plus-implementation-refresh`, `architecture-plus-implementation-and-test-refresh`, `full-workflow-library`, `bounded-workflow-instruction-packet`, and `combined-bounded-stage-context` — selected through programmatic configuration, not CLI flags. Each strategy's evidence is reported through bounded `report.json`, `report.html`, and `report.txt` output with an explicit `available`/`unavailable`/`not-applicable` metric-availability model and no composite score, grade, ranking, or winning strategy.
+- **Evaluate the producer-readiness bridge (v0.4.4):** optionally extend `combined-bounded-stage-context` with the frozen my-dev-kit-orchestrator supplemental implementation/test-context packet and retrieval-report documents plus an observed readiness result, all supplied programmatically (there is no CLI flag), to measure owner, allocation, truncation-cause, supplemental/raw agreement, readiness-agreement, and criticality-overlay evidence without reimplementing upstream owner-selection, allocation, producer-parity, or readiness policy.
 
 ## Quickstart
 
@@ -34,9 +35,12 @@ npm run build
 ### Verify the installation
 
 ```bash
+npm run test
 npm run verify
 ```
 
+`npm test` runs the complete test suite; `npm run verify` runs the remaining non-test verification gates. Running both is complete validation and does not execute the suite twice.
+
 ### Run the fake-agent final demo (deterministic, no external CLIs required)
 
 ```bash
@@ -162,6 +166,7 @@ See [docs/METRICS.md](docs/METRICS.md) for full metric definitions.
 - Provider telemetry dashboards, semantic LLM judging, and cloud API billing integration are not yet implemented
 - The six new stage-context strategies have no CLI flags yet, are configured programmatically, and do not yet include plots, screenshots, or gallery integration
 - The published upstream artifacts the stage-context strategies read do not expose considered-but-unselected reads or unnecessary-read evidence; those metrics report `unavailable` rather than zero
+- The v0.4.4 producer-readiness bridge is released. All bridge inputs are programmatic — there is no CLI flag. The coordinated upstream releases my-dev-kit@1.10.3 and orchestrator@1.2.2 were verified published before lab publication.
 
 ---
 

package/dist/src/evaluation/stageContextExpectations/producerReadinessExpectationTypes.js

@@ -0,0 +1,8 @@
+// v0.4.4 Batch 2: additive, optional expectation facets covering the producer/readiness
+// evidence Batch 1 preserves (selected owners, allocation/truncation evidence on the raw
+// my-dev-kit artifacts, orchestrator readiness, and responsibility criticality). These are
+// a separate axis from StageContextExpectationItemV1/expectedEvidence -- they are the
+// deterministic lab oracle for Batch 2 metrics, not evidence-match expectations. Fully
+// optional so every existing v0.4.3 StageContextExpectationFixtureV1 remains valid and
+// unchanged (schema major stays 1).
+export {};

package/dist/src/evaluation/stageContextExpectations/validation.js

@@ -199,6 +199,11 @@ export function validateStageContextExpectationFixtureV1(value, sourcePath) {
     const statesFailure = validateExpectedStates(root.expectedStates, sourcePath);
     if (statesFailure)
         return statesFailure;
+    if (root.producerReadinessExpectations !== undefined) {
+        const producerReadinessFailure = validateProducerReadinessExpectations(root.producerReadinessExpectations, sourcePath);
+        if (producerReadinessFailure)
+            return producerReadinessFailure;
+    }
     return {
         ok: true,
         sourcePath,
@@ -566,3 +571,198 @@ function validateExpectedStates(statesValue, sourcePath) {
         return immutabilityFailure;
     return null;
 }
+// v0.4.4 Batch 2: additive, optional producer/readiness expectation validation. Structural
+// classification only, mirroring the existing expectation-item validation conventions.
+const OWNER_INCLUSION_VALUES = ["required", "allowed", "forbidden"];
+const READINESS_KIND_VALUES = ["implementation", "test"];
+const READINESS_DECISION_VALUES = ["not-required", "ready", "refresh-required"];
+const CRITICALITY_VALUES = ["critical", "noncritical"];
+const PRODUCER_READINESS_SOURCE_ARTIFACT_VALUES = ["context-capsule", "retrieval-audit-record"];
+function requireNonEmptyExpectationId(item, itemPath, sourcePath) {
+    return requireNonEmptyString(item, "expectationId", `${itemPath}.expectationId`, sourcePath);
+}
+function validateOwnerExpectation(itemValue, itemPath, sourcePath) {
+    if (!isPlainObject(itemValue)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath} must be an object.`, { fieldPath: itemPath });
+    }
+    const idFailure = requireNonEmptyExpectationId(itemValue, itemPath, sourcePath);
+    if (idFailure)
+        return idFailure;
+    if (!OWNER_INCLUSION_VALUES.includes(itemValue.inclusion)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.inclusion is not valid.`, {
+            fieldPath: `${itemPath}.inclusion`,
+            actual: itemValue.inclusion
+        });
+    }
+    if (!PRODUCER_READINESS_SOURCE_ARTIFACT_VALUES.includes(itemValue.sourceArtifact)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.sourceArtifact is not valid.`, {
+            fieldPath: `${itemPath}.sourceArtifact`,
+            actual: itemValue.sourceArtifact
+        });
+    }
+    const ownerIdFailure = requireNonEmptyString(itemValue, "ownerId", `${itemPath}.ownerId`, sourcePath);
+    if (ownerIdFailure)
+        return ownerIdFailure;
+    if (itemValue.notes === undefined || !isStringArray(itemValue.notes)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.notes must be an array of strings.`, {
+            fieldPath: `${itemPath}.notes`
+        });
+    }
+    return null;
+}
+function validateAllocationExpectation(itemValue, itemPath, sourcePath) {
+    if (!isPlainObject(itemValue)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath} must be an object.`, { fieldPath: itemPath });
+    }
+    const idFailure = requireNonEmptyExpectationId(itemValue, itemPath, sourcePath);
+    if (idFailure)
+        return idFailure;
+    const groupIdFailure = requireNonEmptyString(itemValue, "groupId", `${itemPath}.groupId`, sourcePath);
+    if (groupIdFailure)
+        return groupIdFailure;
+    if (itemValue.expectedCapacity !== undefined && itemValue.expectedCapacity !== null && !isNonNegativeInteger(itemValue.expectedCapacity)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedCapacity must be a nonnegative integer or null.`, {
+            fieldPath: `${itemPath}.expectedCapacity`
+        });
+    }
+    if (itemValue.expectedUsedReservation !== undefined &&
+        itemValue.expectedUsedReservation !== null &&
+        !isNonNegativeInteger(itemValue.expectedUsedReservation)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedUsedReservation must be a nonnegative integer or null.`, {
+            fieldPath: `${itemPath}.expectedUsedReservation`
+        });
+    }
+    if (itemValue.expectedRequiredEvidenceIds !== undefined && !isStringArray(itemValue.expectedRequiredEvidenceIds)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedRequiredEvidenceIds must be an array of strings.`, {
+            fieldPath: `${itemPath}.expectedRequiredEvidenceIds`
+        });
+    }
+    if (itemValue.expectedOmitted !== undefined && typeof itemValue.expectedOmitted !== "boolean") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedOmitted must be a boolean.`, {
+            fieldPath: `${itemPath}.expectedOmitted`
+        });
+    }
+    if (itemValue.notes === undefined || !isStringArray(itemValue.notes)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.notes must be an array of strings.`, {
+            fieldPath: `${itemPath}.notes`
+        });
+    }
+    return null;
+}
+function validateReadinessExpectation(itemValue, itemPath, sourcePath) {
+    if (!isPlainObject(itemValue)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath} must be an object.`, { fieldPath: itemPath });
+    }
+    const idFailure = requireNonEmptyExpectationId(itemValue, itemPath, sourcePath);
+    if (idFailure)
+        return idFailure;
+    if (!READINESS_KIND_VALUES.includes(itemValue.kind)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.kind is not valid.`, {
+            fieldPath: `${itemPath}.kind`,
+            actual: itemValue.kind
+        });
+    }
+    if (itemValue.allowedDecisions !== undefined) {
+        if (!isStringArray(itemValue.allowedDecisions) || itemValue.allowedDecisions.some((d) => !READINESS_DECISION_VALUES.includes(d))) {
+            return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.allowedDecisions contains an invalid decision value.`, {
+                fieldPath: `${itemPath}.allowedDecisions`
+            });
+        }
+    }
+    if (itemValue.expectedClassification !== undefined && typeof itemValue.expectedClassification !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedClassification must be a string.`, {
+            fieldPath: `${itemPath}.expectedClassification`
+        });
+    }
+    if (itemValue.expectedIssueCodes !== undefined && !isStringArray(itemValue.expectedIssueCodes)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedIssueCodes must be an array of strings.`, {
+            fieldPath: `${itemPath}.expectedIssueCodes`
+        });
+    }
+    if (itemValue.expectedPrimaryIssueCode !== undefined && typeof itemValue.expectedPrimaryIssueCode !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedPrimaryIssueCode must be a string.`, {
+            fieldPath: `${itemPath}.expectedPrimaryIssueCode`
+        });
+    }
+    if (itemValue.notApplicable !== undefined && typeof itemValue.notApplicable !== "boolean") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.notApplicable must be a boolean.`, {
+            fieldPath: `${itemPath}.notApplicable`
+        });
+    }
+    if (itemValue.notes === undefined || !isStringArray(itemValue.notes)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.notes must be an array of strings.`, {
+            fieldPath: `${itemPath}.notes`
+        });
+    }
+    return null;
+}
+function validateCriticalityExpectation(itemValue, itemPath, sourcePath) {
+    if (!isPlainObject(itemValue)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath} must be an object.`, { fieldPath: itemPath });
+    }
+    const idFailure = requireNonEmptyExpectationId(itemValue, itemPath, sourcePath);
+    if (idFailure)
+        return idFailure;
+    const responsibilityIdFailure = requireNonEmptyString(itemValue, "responsibilityId", `${itemPath}.responsibilityId`, sourcePath);
+    if (responsibilityIdFailure)
+        return responsibilityIdFailure;
+    if (!CRITICALITY_VALUES.includes(itemValue.expectedCriticality)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.expectedCriticality is not valid.`, {
+            fieldPath: `${itemPath}.expectedCriticality`,
+            actual: itemValue.expectedCriticality
+        });
+    }
+    if (typeof itemValue.applicable !== "boolean") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.applicable must be a boolean.`, {
+            fieldPath: `${itemPath}.applicable`
+        });
+    }
+    if (typeof itemValue.requiresFullMapping !== "boolean") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.requiresFullMapping must be a boolean.`, {
+            fieldPath: `${itemPath}.requiresFullMapping`
+        });
+    }
+    if (itemValue.notes === undefined || !isStringArray(itemValue.notes)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.notes must be an array of strings.`, {
+            fieldPath: `${itemPath}.notes`
+        });
+    }
+    return null;
+}
+function validateProducerReadinessExpectations(value, sourcePath) {
+    const fieldPath = "producerReadinessExpectations";
+    if (!isPlainObject(value)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath} must be an object.`, { fieldPath });
+    }
+    const lists = [
+        ["ownerExpectations", value.ownerExpectations, validateOwnerExpectation],
+        ["allocationExpectations", value.allocationExpectations, validateAllocationExpectation],
+        ["readinessExpectations", value.readinessExpectations, validateReadinessExpectation],
+        ["criticalityExpectations", value.criticalityExpectations, validateCriticalityExpectation]
+    ];
+    const seenIds = new Set();
+    for (const [key, listValue, validateItem] of lists) {
+        if (listValue === undefined)
+            continue;
+        if (!Array.isArray(listValue)) {
+            return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath}.${key} must be an array.`, {
+                fieldPath: `${fieldPath}.${key}`
+            });
+        }
+        for (let index = 0; index < listValue.length; index += 1) {
+            const itemPath = `${fieldPath}.${key}[${index}]`;
+            const itemFailure = validateItem(listValue[index], itemPath, sourcePath);
+            if (itemFailure)
+                return itemFailure;
+            const id = listValue[index].expectationId;
+            if (seenIds.has(id)) {
+                return failure(sourcePath, "DUPLICATE_PRODUCER_READINESS_EXPECTATION_ID", `${itemPath}.expectationId "${id}" is duplicated.`, {
+                    fieldPath: `${itemPath}.expectationId`,
+                    actual: id
+                });
+            }
+            seenIds.add(id);
+        }
+    }
+    return null;
+}

package/dist/src/evaluation/stageContextMetrics/calculateAllocationMetrics.js

@@ -0,0 +1,96 @@
+const NO_BORROW_EVIDENCE_REASON = "The frozen my-dev-kit artifacts do not expose cross-group capacity borrowing evidence.";
+export function calculateAllocationFactsForGroups(evidenceGroups, sourceArtifact, sourceInstance) {
+    const requiredGroupCapacity = [];
+    const usedReservation = [];
+    const borrowedCapacity = [];
+    const unusedCapacity = [];
+    for (const group of evidenceGroups) {
+        requiredGroupCapacity.push({
+            groupId: group.id,
+            sourceArtifact,
+            sourceInstance,
+            value: group.limit,
+            unit: "items",
+            availability: group.limit === null ? "unavailable" : "available",
+            reason: group.limit === null ? "No hard limit is declared for this evidence group." : null
+        });
+        usedReservation.push({
+            groupId: group.id,
+            sourceArtifact,
+            sourceInstance,
+            value: group.usedCount,
+            unit: "items",
+            availability: "available",
+            reason: null
+        });
+        borrowedCapacity.push({
+            groupId: group.id,
+            sourceArtifact,
+            sourceInstance,
+            value: null,
+            unit: "items",
+            availability: "unavailable",
+            reason: NO_BORROW_EVIDENCE_REASON
+        });
+        if (group.limit === null) {
+            unusedCapacity.push({
+                groupId: group.id,
+                sourceArtifact,
+                sourceInstance,
+                value: null,
+                unit: "items",
+                availability: "unavailable",
+                reason: "No hard limit is declared for this evidence group, so unused capacity cannot be computed."
+            });
+            continue;
+        }
+        const unused = group.limit - group.usedCount;
+        if (unused < 0) {
+            unusedCapacity.push({
+                groupId: group.id,
+                sourceArtifact,
+                sourceInstance,
+                value: null,
+                unit: "items",
+                availability: "unavailable",
+                reason: `Computed unused capacity was negative (used ${group.usedCount} exceeds limit ${group.limit}); treated as a data inconsistency rather than a valid value.`
+            });
+            continue;
+        }
+        unusedCapacity.push({
+            groupId: group.id,
+            sourceArtifact,
+            sourceInstance,
+            value: unused,
+            unit: "items",
+            availability: "available",
+            reason: null
+        });
+    }
+    return { requiredGroupCapacity, usedReservation, borrowedCapacity, unusedCapacity };
+}
+export function calculateRequiredEvidenceOmitted(matches, sourceArtifactTruncated) {
+    const missing = matches.filter((m) => m.inclusion === "required" && m.outcome === "missing");
+    if (missing.length === 0) {
+        return {
+            metric: { availability: "not-applicable", count: null, evidenceKeys: [], reason: "No required expectation is missing from observed evidence." },
+            entries: []
+        };
+    }
+    const entries = missing.map((m) => ({
+        evidenceKey: m.targetKey,
+        groupId: null,
+        truncationReported: sourceArtifactTruncated[m.sourceArtifact] ?? false,
+        sourceArtifact: m.sourceArtifact
+    }));
+    return {
+        metric: { availability: "available", count: entries.length, evidenceKeys: entries.map((e) => e.evidenceKey), reason: null },
+        entries
+    };
+}
+// Not currently consumed by the calculators above, but kept available for callers that
+// want to cross-check allocation expectations directly (bounded, deterministic; the lab
+// still never recalculates the producer's allocation decision).
+export function findAllocationExpectationForGroup(expectations, groupId) {
+    return (expectations ?? []).find((e) => e.groupId === groupId);
+}

package/dist/src/evaluation/stageContextMetrics/calculateCriticalityMetrics.js

@@ -0,0 +1,112 @@
+function findMapping(mappings, responsibilityId) {
+    return mappings?.find((m) => m.responsibilityId === responsibilityId);
+}
+export function calculateCriticalityMetrics(mappings, expectations) {
+    const list = expectations ?? [];
+    const overlayAgreement = [];
+    const missingCriticalityResponsibilityIds = [];
+    const conflictingCriticalityResponsibilityIds = [];
+    for (const e of list) {
+        if (!e.applicable) {
+            overlayAgreement.push({
+                responsibilityId: e.responsibilityId,
+                expectedCriticality: e.expectedCriticality,
+                observedCriticality: findMapping(mappings, e.responsibilityId)?.criticality ?? null,
+                agreement: null,
+                availability: "not-applicable",
+                reason: "Expectation is marked not applicable."
+            });
+            continue;
+        }
+        if (mappings === undefined) {
+            overlayAgreement.push({
+                responsibilityId: e.responsibilityId,
+                expectedCriticality: e.expectedCriticality,
+                observedCriticality: null,
+                agreement: null,
+                availability: "unavailable",
+                reason: "No raw responsibility-mapping evidence was supplied."
+            });
+            missingCriticalityResponsibilityIds.push(e.responsibilityId);
+            continue;
+        }
+        const mapping = findMapping(mappings, e.responsibilityId);
+        if (mapping === undefined) {
+            overlayAgreement.push({
+                responsibilityId: e.responsibilityId,
+                expectedCriticality: e.expectedCriticality,
+                observedCriticality: null,
+                agreement: null,
+                availability: "unavailable",
+                reason: "No raw mapping entry exists for this responsibility ID."
+            });
+            missingCriticalityResponsibilityIds.push(e.responsibilityId);
+            continue;
+        }
+        const agreement = mapping.criticality === e.expectedCriticality;
+        overlayAgreement.push({
+            responsibilityId: e.responsibilityId,
+            expectedCriticality: e.expectedCriticality,
+            observedCriticality: mapping.criticality,
+            agreement,
+            availability: "available",
+            reason: null
+        });
+        if (!agreement)
+            conflictingCriticalityResponsibilityIds.push(e.responsibilityId);
+    }
+    const unexpectedCriticalityResponsibilityIds = list.length === 0 || mappings === undefined
+        ? []
+        : mappings.filter((m) => !list.some((e) => e.responsibilityId === m.responsibilityId)).map((m) => m.responsibilityId);
+    const fullyMappedCriticalIds = [];
+    const partiallyMappedCriticalIds = [];
+    const unmappedCriticalIds = [];
+    const missingMappingEvidenceCriticalIds = [];
+    for (const e of list) {
+        if (!e.applicable || !e.requiresFullMapping || e.expectedCriticality !== "critical")
+            continue;
+        const mapping = findMapping(mappings, e.responsibilityId);
+        if (mapping === undefined) {
+            missingMappingEvidenceCriticalIds.push(e.responsibilityId);
+            continue;
+        }
+        if (mapping.mappingStatus === "mapped")
+            fullyMappedCriticalIds.push(e.responsibilityId);
+        else if (mapping.mappingStatus === "partially-mapped")
+            partiallyMappedCriticalIds.push(e.responsibilityId);
+        else if (mapping.mappingStatus === "unmapped")
+            unmappedCriticalIds.push(e.responsibilityId);
+        // mapping.mappingStatus === "not-applicable": excluded from the denominator entirely.
+    }
+    const denominator = fullyMappedCriticalIds.length + partiallyMappedCriticalIds.length + unmappedCriticalIds.length;
+    const mappedCriticalCompleteness = denominator === 0
+        ? {
+            availability: "not-applicable",
+            numerator: null,
+            denominator: null,
+            rate: null,
+            matchedExpectationIds: [],
+            missingExpectationIds: [],
+            reason: "No applicable critical responsibility requiring full mapping has resolvable mapping status."
+        }
+        : {
+            availability: "available",
+            numerator: fullyMappedCriticalIds.length,
+            denominator,
+            rate: fullyMappedCriticalIds.length / denominator,
+            matchedExpectationIds: fullyMappedCriticalIds,
+            missingExpectationIds: [...partiallyMappedCriticalIds, ...unmappedCriticalIds],
+            reason: null
+        };
+    return {
+        overlayAgreement,
+        missingCriticalityResponsibilityIds,
+        conflictingCriticalityResponsibilityIds,
+        unexpectedCriticalityResponsibilityIds,
+        mappedCriticalCompleteness,
+        fullyMappedCriticalIds,
+        partiallyMappedCriticalIds,
+        unmappedCriticalIds,
+        missingMappingEvidenceCriticalIds
+    };
+}

package/dist/src/evaluation/stageContextMetrics/calculateOwnerMetrics.js

@@ -0,0 +1,84 @@
+export function collectSelectedOwnerEvidence(selectedOwners, sourceArtifact, sourceInstance) {
+    return selectedOwners.map((item) => ({
+        ownerId: item.id,
+        sourceArtifact,
+        sourceInstance,
+        itemKind: item.itemKind,
+        path: item.path ?? null,
+        symbolId: item.symbolId ?? null,
+        sourceFieldPath: `${sourceInstance}.selectedOwners`
+    }));
+}
+function notApplicableRatio(reason) {
+    return { availability: "not-applicable", numerator: null, denominator: null, rate: null, matchedExpectationIds: [], missingExpectationIds: [], reason };
+}
+function unavailableRatio(reason) {
+    return { availability: "unavailable", numerator: null, denominator: null, rate: null, matchedExpectationIds: [], missingExpectationIds: [], reason };
+}
+function notApplicableCount(reason) {
+    return { availability: "not-applicable", count: null, evidenceKeys: [], reason };
+}
+function unavailableCount(reason) {
+    return { availability: "unavailable", count: null, evidenceKeys: [], reason };
+}
+export function calculateOwnerMetrics(selectedOwnerEvidence, ownerExpectations) {
+    const evidence = selectedOwnerEvidence ?? [];
+    const evidenceUnavailable = selectedOwnerEvidence === undefined;
+    const unavailableReason = "Producer selected-owner evidence was not supplied to this metric.";
+    const requiredIds = new Set((ownerExpectations ?? []).filter((e) => e.inclusion === "required").map((e) => e.ownerId));
+    const allowedIds = new Set((ownerExpectations ?? []).filter((e) => e.inclusion === "allowed").map((e) => e.ownerId));
+    const forbiddenIds = new Set((ownerExpectations ?? []).filter((e) => e.inclusion === "forbidden").map((e) => e.ownerId));
+    const hasClosedSet = requiredIds.size > 0 || allowedIds.size > 0;
+    const observedIds = new Set(evidence.map((e) => e.ownerId));
+    const expectedOwnerPresent = evidenceUnavailable
+        ? unavailableRatio(unavailableReason)
+        : requiredIds.size === 0
+            ? notApplicableRatio("The expectation fixture contains no required owner expectations.")
+            : (() => {
+                const matched = [...requiredIds].filter((id) => observedIds.has(id));
+                const missing = [...requiredIds].filter((id) => !observedIds.has(id));
+                return {
+                    availability: "available",
+                    numerator: matched.length,
+                    denominator: requiredIds.size,
+                    rate: matched.length / requiredIds.size,
+                    matchedExpectationIds: matched,
+                    missingExpectationIds: missing,
+                    reason: null
+                };
+            })();
+    const forbiddenOwnerPresent = evidenceUnavailable
+        ? unavailableRatio(unavailableReason)
+        : forbiddenIds.size === 0
+            ? notApplicableRatio("The expectation fixture contains no forbidden owner expectations.")
+            : (() => {
+                const present = [...forbiddenIds].filter((id) => observedIds.has(id));
+                const absent = [...forbiddenIds].filter((id) => !observedIds.has(id));
+                return {
+                    availability: "available",
+                    numerator: present.length,
+                    denominator: forbiddenIds.size,
+                    rate: present.length / forbiddenIds.size,
+                    matchedExpectationIds: present,
+                    missingExpectationIds: absent,
+                    reason: null
+                };
+            })();
+    const falsePositiveCount = evidenceUnavailable
+        ? unavailableCount(unavailableReason)
+        : !hasClosedSet && forbiddenIds.size === 0
+            ? notApplicableCount("The expectation fixture defines neither a closed owner set nor forbidden owners.")
+            : (() => {
+                const falsePositives = [...observedIds].filter((id) => forbiddenIds.has(id) || (hasClosedSet && !requiredIds.has(id) && !allowedIds.has(id)));
+                return { availability: "available", count: falsePositives.length, evidenceKeys: falsePositives, reason: null };
+            })();
+    const falseNegativeCount = evidenceUnavailable
+        ? unavailableCount(unavailableReason)
+        : requiredIds.size === 0
+            ? notApplicableCount("The expectation fixture contains no required owner expectations.")
+            : (() => {
+                const falseNegatives = [...requiredIds].filter((id) => !observedIds.has(id));
+                return { availability: "available", count: falseNegatives.length, evidenceKeys: falseNegatives, reason: null };
+            })();
+    return { selectedOwnerEvidence: [...evidence], expectedOwnerPresent, forbiddenOwnerPresent, falsePositiveCount, falseNegativeCount };
+}