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

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/calculateArtifactStateMetrics.js

@@ -0,0 +1,130 @@
+import { isDeepStrictEqual } from "node:util";
+function compareValue(sourceArtifact, sourceInstance, expectationFieldPath, artifactFieldPath, expected, actual, matched) {
+    return {
+        sourceArtifact,
+        sourceInstance,
+        expectationFieldPath,
+        artifactFieldPath,
+        availability: "available",
+        expected,
+        actual,
+        matched,
+        reason: null
+    };
+}
+function unavailableComparison(sourceArtifact, sourceInstance, expectationFieldPath, expected, reason) {
+    return {
+        sourceArtifact,
+        sourceInstance,
+        expectationFieldPath,
+        artifactFieldPath: null,
+        availability: "unavailable",
+        expected,
+        actual: null,
+        matched: null,
+        reason
+    };
+}
+export function compareExpectedContextCapsuleState(expected, artifact, sourceInstance) {
+    if (expected === undefined)
+        return [];
+    const comparisons = [];
+    const SA = "context-capsule";
+    if (expected.contextAdequacyStatus !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "contextAdequacyStatus", "contextAdequacy.status", expected.contextAdequacyStatus, artifact.contextAdequacy.status, artifact.contextAdequacy.status === expected.contextAdequacyStatus));
+    }
+    if (expected.roleAdequacyStatus !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "roleAdequacyStatus", "roleAdequacy.status", expected.roleAdequacyStatus, artifact.roleAdequacy.status, artifact.roleAdequacy.status === expected.roleAdequacyStatus));
+    }
+    if (expected.freshnessState !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "freshnessState", "freshness.state", expected.freshnessState, artifact.freshness.state, artifact.freshness.state === expected.freshnessState));
+    }
+    if (expected.truncated !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "truncated", "truncation.truncated", expected.truncated, artifact.truncation.truncated, artifact.truncation.truncated === expected.truncated));
+    }
+    if (expected.fullFileFallbackUsed !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "fullFileFallbackUsed", "fullFileFallback.used", expected.fullFileFallbackUsed, artifact.fullFileFallback.used, artifact.fullFileFallback.used === expected.fullFileFallbackUsed));
+    }
+    if (expected.unresolvedItemIds !== undefined) {
+        comparisons.push(unavailableComparison(SA, sourceInstance, "unresolvedItemIds", expected.unresolvedItemIds, "ContextCapsule unresolvedItems do not expose stable item IDs."));
+    }
+    if (expected.warningCount !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "warningCount", "warnings.length", expected.warningCount, artifact.warnings.length, artifact.warnings.length === expected.warningCount));
+    }
+    return comparisons;
+}
+export function compareExpectedRetrievalAuditState(expected, artifact, sourceInstance) {
+    if (expected === undefined)
+        return [];
+    const comparisons = [];
+    const SA = "retrieval-audit-record";
+    if (expected.contextAdequacyStatus !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "contextAdequacyStatus", "contextAdequacy.status", expected.contextAdequacyStatus, artifact.contextAdequacy.status, artifact.contextAdequacy.status === expected.contextAdequacyStatus));
+    }
+    if (expected.roleAdequacyStatus !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "roleAdequacyStatus", "roleAdequacy.status", expected.roleAdequacyStatus, artifact.roleAdequacy.status, artifact.roleAdequacy.status === expected.roleAdequacyStatus));
+    }
+    if (expected.freshnessState !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "freshnessState", "freshness.state", expected.freshnessState, artifact.freshness.state, artifact.freshness.state === expected.freshnessState));
+    }
+    if (expected.truncated !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "truncated", "truncation.truncated", expected.truncated, artifact.truncation.truncated, artifact.truncation.truncated === expected.truncated));
+    }
+    if (expected.fullFileFallbackUsed !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "fullFileFallbackUsed", "fullFileFallback.used", expected.fullFileFallbackUsed, artifact.fullFileFallback.used, artifact.fullFileFallback.used === expected.fullFileFallbackUsed));
+    }
+    if (expected.unresolvedItemIds !== undefined) {
+        comparisons.push(unavailableComparison(SA, sourceInstance, "unresolvedItemIds", expected.unresolvedItemIds, "RetrievalAuditRecord does not serialize unresolved item IDs."));
+    }
+    if (expected.warningCount !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "warningCount", "warnings.length", expected.warningCount, artifact.warnings.length, artifact.warnings.length === expected.warningCount));
+    }
+    return comparisons;
+}
+export function compareExpectedWorkflowInstructionPacketState(expected, artifact, sourceInstance) {
+    if (expected === undefined)
+        return [];
+    const comparisons = [];
+    const SA = "workflow-instruction-packet";
+    if (expected.adequacyStatus !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "adequacyStatus", "adequacy.status", expected.adequacyStatus, artifact.adequacy.status, artifact.adequacy.status === expected.adequacyStatus));
+    }
+    if (expected.truncated !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "truncated", "truncation.truncated", expected.truncated, artifact.truncation.truncated, artifact.truncation.truncated === expected.truncated));
+    }
+    if (expected.unresolvedReferences !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "unresolvedReferences", "unresolvedReferences", expected.unresolvedReferences, artifact.unresolvedReferences, isDeepStrictEqual(artifact.unresolvedReferences, expected.unresolvedReferences)));
+    }
+    if (expected.warningCount !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "warningCount", "warnings.length", expected.warningCount, artifact.warnings.length, artifact.warnings.length === expected.warningCount));
+    }
+    return comparisons;
+}
+export function compareExpectedTargetImmutabilityState(expected, targetImmutability) {
+    if (expected === undefined)
+        return [];
+    const SA = "target-immutability";
+    const expectationFieldPath = "expectedStates.targetImmutability.newMutationCount";
+    if (targetImmutability === undefined) {
+        return [
+            unavailableComparison(SA, "target", expectationFieldPath, expected.newMutationCount, "Target immutability configuration was not supplied for this strategy run.")
+        ];
+    }
+    if (targetImmutability.availability === "unavailable") {
+        return [unavailableComparison(SA, "target", expectationFieldPath, expected.newMutationCount, targetImmutability.reason)];
+    }
+    const comparison = targetImmutability.comparison;
+    return [
+        {
+            sourceArtifact: SA,
+            sourceInstance: "target",
+            expectationFieldPath,
+            artifactFieldPath: "targetImmutability.comparison.newMutationCount",
+            availability: "available",
+            expected: expected.newMutationCount,
+            actual: comparison.newMutationCount,
+            matched: expected.newMutationCount === comparison.newMutationCount,
+            reason: null
+        }
+    ];
+}

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

@@ -0,0 +1,85 @@
+function estimateTokens(characterCount) {
+    return Math.ceil(characterCount / 4);
+}
+function pairSources(pair, labelPrefix) {
+    const sources = [];
+    const capsuleCharacterCount = JSON.stringify(pair.contextCapsule).length;
+    sources.push({
+        sourceInstance: `${labelPrefix}.contextCapsule`,
+        sourceKind: "context-capsule",
+        characterCount: capsuleCharacterCount,
+        estimatedTokenCount: estimateTokens(capsuleCharacterCount)
+    });
+    if (pair.retrievalAuditRecord) {
+        const auditCharacterCount = JSON.stringify(pair.retrievalAuditRecord).length;
+        sources.push({
+            sourceInstance: `${labelPrefix}.retrievalAuditRecord`,
+            sourceKind: "retrieval-audit-record",
+            characterCount: auditCharacterCount,
+            estimatedTokenCount: estimateTokens(auditCharacterCount)
+        });
+    }
+    return sources;
+}
+export function calculateV043ExecutionContextSize(execution) {
+    const sources = [];
+    switch (execution.strategyId) {
+        case "architecture-context-only": {
+            const payload = execution.payload;
+            sources.push(...pairSources(payload.architecture, "architecture"));
+            break;
+        }
+        case "architecture-plus-implementation-refresh": {
+            const payload = execution.payload;
+            sources.push(...pairSources(payload.architecture, "architecture"));
+            sources.push(...pairSources(payload.implementation, "implementation"));
+            break;
+        }
+        case "architecture-plus-implementation-and-test-refresh": {
+            const payload = execution.payload;
+            sources.push(...pairSources(payload.architecture, "architecture"));
+            sources.push(...pairSources(payload.implementation, "implementation"));
+            sources.push(...pairSources(payload.testImplementation, "testImplementation"));
+            break;
+        }
+        case "full-workflow-library": {
+            const payload = execution.payload;
+            const characterCount = payload.fullWorkflowLibrary.rawText.length;
+            sources.push({
+                sourceInstance: "fullWorkflowLibrary.rawText",
+                sourceKind: "full-workflow-library-text",
+                characterCount,
+                estimatedTokenCount: estimateTokens(characterCount)
+            });
+            break;
+        }
+        case "bounded-workflow-instruction-packet": {
+            const payload = execution.payload;
+            const characterCount = JSON.stringify(payload.workflowInstructionPacket).length;
+            sources.push({
+                sourceInstance: "workflowInstructionPacket",
+                sourceKind: "workflow-instruction-packet",
+                characterCount,
+                estimatedTokenCount: estimateTokens(characterCount)
+            });
+            break;
+        }
+        case "combined-bounded-stage-context": {
+            const payload = execution.payload;
+            payload.contextArtifacts.forEach((pair, index) => {
+                sources.push(...pairSources(pair, `contextArtifacts[${index}]`));
+            });
+            const characterCount = JSON.stringify(payload.workflowInstructionPacket).length;
+            sources.push({
+                sourceInstance: "workflowInstructionPacket",
+                sourceKind: "workflow-instruction-packet",
+                characterCount,
+                estimatedTokenCount: estimateTokens(characterCount)
+            });
+            break;
+        }
+    }
+    const totalCharacterCount = sources.reduce((sum, source) => sum + source.characterCount, 0);
+    const totalEstimatedTokenCount = sources.reduce((sum, source) => sum + source.estimatedTokenCount, 0);
+    return { availability: "available", sources, totalCharacterCount, totalEstimatedTokenCount };
+}

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/calculateExpectationMetrics.js

@@ -0,0 +1,103 @@
+import { buildStageContextExpectationTargetKey } from "./targetKeys.js";
+const INSTRUCTION_CATEGORIES = ["workflow", "stage", "command", "rule", "report-contract"];
+function buildRatioMetric(filtered, targetOutcome, notApplicableReason) {
+    if (filtered.length === 0) {
+        return {
+            availability: "not-applicable",
+            numerator: null,
+            denominator: null,
+            rate: null,
+            matchedExpectationIds: [],
+            missingExpectationIds: [],
+            reason: notApplicableReason
+        };
+    }
+    const matchedExpectationIds = [];
+    const missingExpectationIds = [];
+    for (const match of filtered) {
+        if (match.outcome === targetOutcome) {
+            matchedExpectationIds.push(match.expectationId);
+        }
+        else {
+            missingExpectationIds.push(match.expectationId);
+        }
+    }
+    return {
+        availability: "available",
+        numerator: matchedExpectationIds.length,
+        denominator: filtered.length,
+        rate: matchedExpectationIds.length / filtered.length,
+        matchedExpectationIds,
+        missingExpectationIds,
+        reason: null
+    };
+}
+export function calculateRequiredEvidenceRecall(matches) {
+    const filtered = matches.filter((match) => match.inclusion === "required");
+    return buildRatioMetric(filtered, "matched", "The expectation fixture contains no required evidence items.");
+}
+export function calculateAllowedEvidenceCoverage(matches) {
+    const filtered = matches.filter((match) => match.inclusion === "allowed");
+    return buildRatioMetric(filtered, "matched", "The expectation fixture contains no allowed evidence items.");
+}
+export function calculateForbiddenEvidenceInclusion(matches) {
+    const filtered = matches.filter((match) => match.inclusion === "forbidden");
+    return buildRatioMetric(filtered, "violated", "The expectation fixture contains no forbidden evidence items.");
+}
+export function calculateRequiredProvenanceRecall(matches) {
+    const filtered = matches.filter((match) => match.inclusion === "required" && match.category === "provenance");
+    return buildRatioMetric(filtered, "matched", "The expectation fixture contains no required provenance items.");
+}
+export function calculateIrrelevantFileInclusion(expectations, observedEvidence) {
+    const fileEvidence = observedEvidence.filter((evidence) => evidence.sourceArtifact === "context-capsule" && evidence.category === "file");
+    if (fileEvidence.length === 0) {
+        return {
+            availability: "not-applicable",
+            count: null,
+            evidenceKeys: [],
+            reason: "The completed strategy contains no context-capsule file evidence."
+        };
+    }
+    const coveredKeys = new Set(expectations.expectedEvidence
+        .filter((item) => item.sourceArtifact === "context-capsule" &&
+        item.category === "file" &&
+        (item.inclusion === "required" || item.inclusion === "allowed"))
+        .map((item) => buildStageContextExpectationTargetKey(item)));
+    const seen = new Set();
+    const evidenceKeys = [];
+    for (const evidence of fileEvidence) {
+        if (coveredKeys.has(evidence.targetKey))
+            continue;
+        if (seen.has(evidence.targetKey))
+            continue;
+        seen.add(evidence.targetKey);
+        evidenceKeys.push(evidence.targetKey);
+    }
+    return { availability: "available", count: evidenceKeys.length, evidenceKeys, reason: null };
+}
+export function calculateIrrelevantInstructionInclusion(expectations, observedEvidence) {
+    const instructionEvidence = observedEvidence.filter((evidence) => (evidence.sourceArtifact === "workflow-instruction-packet" || evidence.sourceArtifact === "full-workflow-library") &&
+        INSTRUCTION_CATEGORIES.includes(evidence.category));
+    if (instructionEvidence.length === 0) {
+        return {
+            availability: "not-applicable",
+            count: null,
+            evidenceKeys: [],
+            reason: "The completed strategy contains no workflow instruction evidence."
+        };
+    }
+    const coveredKeys = new Set(expectations.expectedEvidence
+        .filter((item) => INSTRUCTION_CATEGORIES.includes(item.category) && (item.inclusion === "required" || item.inclusion === "allowed"))
+        .map((item) => buildStageContextExpectationTargetKey(item)));
+    const seen = new Set();
+    const evidenceKeys = [];
+    for (const evidence of instructionEvidence) {
+        if (coveredKeys.has(evidence.targetKey))
+            continue;
+        if (seen.has(evidence.targetKey))
+            continue;
+        seen.add(evidence.targetKey);
+        evidenceKeys.push(evidence.targetKey);
+    }
+    return { availability: "available", count: evidenceKeys.length, evidenceKeys, reason: null };
+}

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 };
+}