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

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

@@ -0,0 +1,137 @@
+function dedupeEvidence(records) {
+    const seen = new Set();
+    const result = [];
+    for (const record of records) {
+        const key = `${record.sourceInstance} ${record.category} ${record.targetKey}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(record);
+    }
+    return result;
+}
+function workflowStableIdKey(sourceArtifact, category, id) {
+    return `${sourceArtifact}|${category}|id:${id}`;
+}
+function provenanceKey(sourceArtifact, evidenceId) {
+    return `${sourceArtifact}|provenance|evidenceId:${evidenceId}`;
+}
+export function collectWorkflowInstructionPacketEvidence(artifact, sourceInstance) {
+    const SOURCE_ARTIFACT = "workflow-instruction-packet";
+    const records = [];
+    records.push({
+        sourceArtifact: SOURCE_ARTIFACT,
+        sourceInstance,
+        category: "workflow",
+        targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "workflow", artifact.workflowId),
+        sourceFieldPath: "workflowId"
+    });
+    records.push({
+        sourceArtifact: SOURCE_ARTIFACT,
+        sourceInstance,
+        category: "stage",
+        targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "stage", artifact.stageId),
+        sourceFieldPath: "stageId"
+    });
+    artifact.resolvedCommands.forEach((command, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "command",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "command", command.id),
+            sourceFieldPath: `resolvedCommands[${index}].id`
+        });
+    });
+    artifact.resolvedRules.forEach((rule, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "rule",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "rule", rule.id),
+            sourceFieldPath: `resolvedRules[${index}].id`
+        });
+    });
+    records.push({
+        sourceArtifact: SOURCE_ARTIFACT,
+        sourceInstance,
+        category: "report-contract",
+        targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "report-contract", artifact.reportContract.id),
+        sourceFieldPath: "reportContract.id"
+    });
+    artifact.resolutionProvenance.forEach((entry, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "provenance",
+            targetKey: provenanceKey(SOURCE_ARTIFACT, entry.sourceEntryId),
+            sourceFieldPath: `resolutionProvenance[${index}].sourceEntryId`
+        });
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "provenance",
+            targetKey: provenanceKey(SOURCE_ARTIFACT, entry.referencedEntryId),
+            sourceFieldPath: `resolutionProvenance[${index}].referencedEntryId`
+        });
+    });
+    return dedupeEvidence(records);
+}
+export function collectFullWorkflowLibraryEvidence(fixture, sourceInstance) {
+    const SOURCE_ARTIFACT = "full-workflow-library";
+    const records = [];
+    fixture.workflowIds.forEach((id, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "workflow",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "workflow", id),
+            sourceFieldPath: `workflowIds[${index}]`
+        });
+    });
+    fixture.stageIds.forEach((id, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "stage",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "stage", id),
+            sourceFieldPath: `stageIds[${index}]`
+        });
+    });
+    fixture.commandIds.forEach((id, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "command",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "command", id),
+            sourceFieldPath: `commandIds[${index}]`
+        });
+    });
+    fixture.ruleIds.forEach((id, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "rule",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "rule", id),
+            sourceFieldPath: `ruleIds[${index}]`
+        });
+    });
+    fixture.reportContractIds.forEach((id, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "report-contract",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "report-contract", id),
+            sourceFieldPath: `reportContractIds[${index}]`
+        });
+    });
+    fixture.provenanceEvidenceIds.forEach((id, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "provenance",
+            targetKey: provenanceKey(SOURCE_ARTIFACT, id),
+            sourceFieldPath: `provenanceEvidenceIds[${index}]`
+        });
+    });
+    return dedupeEvidence(records);
+}

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

@@ -0,0 +1,127 @@
+import { collectSelectedOwnerEvidence, calculateOwnerMetrics } from "./calculateOwnerMetrics.js";
+import { calculateAllocationFactsForGroups } from "./calculateAllocationMetrics.js";
+import { classifyTruncationRecords } from "./calculateTruncationClassification.js";
+import { calculateSupplementalRawAgreement } from "./calculateSupplementalRawAgreement.js";
+import { calculateReadinessAgreementMetrics } from "./calculateReadinessAgreement.js";
+import { calculateCriticalityMetrics } from "./calculateCriticalityMetrics.js";
+function ownerExpectationsFor(expectations, sourceArtifact) {
+    return expectations?.ownerExpectations?.filter((e) => e.sourceArtifact === sourceArtifact);
+}
+function evaluateSide(input, expectations) {
+    const producerExpectations = expectations?.producerReadinessExpectations;
+    // Owner-selection and allocation-group evidence only exist on ContextCapsule (Batch 1
+    // contract-lock evidence: RetrievalAuditRecord has no selectedOwners/evidenceGroups
+    // fields). Truncation and responsibility-mapping evidence exist on both.
+    const capsule = input.contextCapsule;
+    const truncationArtifact = input.contextCapsule ?? input.retrievalAuditRecord;
+    const rawForAgreement = input.contextCapsule ?? input.retrievalAuditRecord;
+    const selectedOwnerEvidence = capsule ? collectSelectedOwnerEvidence(capsule.selectedOwners, "context-capsule", input.role) : undefined;
+    const ownerEvaluation = calculateOwnerMetrics(selectedOwnerEvidence, ownerExpectationsFor(producerExpectations, "context-capsule"));
+    const allocationFacts = capsule
+        ? calculateAllocationFactsForGroups(capsule.evidenceGroups, "context-capsule", input.role)
+        : { requiredGroupCapacity: [], usedReservation: [], borrowedCapacity: [], unusedCapacity: [] };
+    const allocationEvaluation = {
+        ...allocationFacts,
+        requiredEvidenceOmitted: {
+            availability: "not-applicable",
+            count: null,
+            evidenceKeys: [],
+            reason: "Batch 3 bridge evaluation derives omission from truncation records, not expectation matches; see truncationEvaluation."
+        },
+        requiredEvidenceOmittedEntries: []
+    };
+    const truncationSourceArtifact = input.contextCapsule ? "context-capsule" : "retrieval-audit-record";
+    const truncationEvaluation = truncationArtifact
+        ? classifyTruncationRecords(truncationArtifact.truncation.records, truncationSourceArtifact, input.role)
+        : [];
+    const packetAgreement = input.packet !== undefined || rawForAgreement !== undefined ? calculateSupplementalRawAgreement(input.packet, rawForAgreement) : null;
+    const reportAgreement = input.report !== undefined || rawForAgreement !== undefined ? calculateSupplementalRawAgreement(input.report, rawForAgreement) : null;
+    return { ownerEvaluation, allocationEvaluation, truncationEvaluation, packetAgreement, reportAgreement };
+}
+// Builds bridge-evaluator input from an already-loaded combined-bounded-stage-context
+// execution payload (Batch 3 section 12.1: "accept already-read raw, supplemental,
+// readiness, and expectation inputs"). Never reads a file itself.
+export function buildProducerReadinessBridgeInputFromCombinedPayload(payload, expectations) {
+    const implementationPair = payload.contextArtifacts.find((p) => p.role === "implementation");
+    const testPair = payload.contextArtifacts.find((p) => p.role === "test-implementation");
+    const hasImplementationSide = implementationPair !== undefined || payload.implementationContextPacket !== undefined || payload.implementationContextRetrievalReport !== undefined;
+    const hasTestSide = testPair !== undefined || payload.testContextPacket !== undefined || payload.testContextRetrievalReport !== undefined;
+    return {
+        implementation: hasImplementationSide
+            ? {
+                role: "implementation",
+                contextCapsule: implementationPair?.contextCapsule,
+                retrievalAuditRecord: implementationPair?.retrievalAuditRecord,
+                packet: payload.implementationContextPacket,
+                packetSourcePath: payload.implementationContextPacketSourcePath,
+                report: payload.implementationContextRetrievalReport
+            }
+            : undefined,
+        testImplementation: hasTestSide
+            ? {
+                role: "test-implementation",
+                contextCapsule: testPair?.contextCapsule,
+                retrievalAuditRecord: testPair?.retrievalAuditRecord,
+                packet: payload.testContextPacket,
+                packetSourcePath: payload.testContextPacketSourcePath,
+                report: payload.testContextRetrievalReport
+            }
+            : undefined,
+        readiness: payload.readiness,
+        expectations
+    };
+}
+export function evaluateProducerReadinessBridge(input) {
+    const hasAnyInput = input.implementation !== undefined || input.testImplementation !== undefined || input.readiness !== undefined;
+    if (!hasAnyInput) {
+        return {
+            status: "not-applicable",
+            reason: "No producer-readiness bridge inputs (supplemental artifacts or readiness result) were supplied.",
+            implementation: null,
+            testImplementation: null,
+            readinessAgreement: null,
+            criticalityEvaluation: null,
+            warnings: [],
+            evidenceReferences: []
+        };
+    }
+    const evidenceReferences = [];
+    const warnings = [];
+    let implementation = null;
+    if (input.implementation !== undefined) {
+        const evaluated = evaluateSide(input.implementation, input.expectations);
+        implementation = { role: "implementation", ...evaluated };
+        if (input.implementation.packetSourcePath)
+            evidenceReferences.push(input.implementation.packetSourcePath);
+    }
+    let testImplementation = null;
+    if (input.testImplementation !== undefined) {
+        const evaluated = evaluateSide(input.testImplementation, input.expectations);
+        testImplementation = { role: "test-implementation", ...evaluated };
+        if (input.testImplementation.packetSourcePath)
+            evidenceReferences.push(input.testImplementation.packetSourcePath);
+    }
+    let readinessAgreement = null;
+    if (input.readiness !== undefined) {
+        const readinessExpectations = input.expectations.producerReadinessExpectations?.readinessExpectations;
+        const matchingExpectation = readinessExpectations?.find((e) => e.kind === input.readiness.kind);
+        const relevantPacket = input.readiness.kind === "implementation" ? input.implementation?.packet : input.testImplementation?.packet;
+        const relevantPacketPath = input.readiness.kind === "implementation" ? input.implementation?.packetSourcePath : input.testImplementation?.packetSourcePath;
+        readinessAgreement = calculateReadinessAgreementMetrics(input.readiness, matchingExpectation, relevantPacket, relevantPacketPath);
+    }
+    const criticalityMappings = input.testImplementation?.retrievalAuditRecord?.responsibilityMappings.mappings ??
+        input.testImplementation?.contextCapsule?.responsibilityMappings.mappings ??
+        input.implementation?.retrievalAuditRecord?.responsibilityMappings.mappings ??
+        input.implementation?.contextCapsule?.responsibilityMappings.mappings;
+    const criticalityEvaluation = calculateCriticalityMetrics(criticalityMappings, input.expectations.producerReadinessExpectations?.criticalityExpectations);
+    return {
+        status: "evaluated",
+        reason: null,
+        implementation,
+        testImplementation,
+        readinessAgreement,
+        criticalityEvaluation,
+        warnings,
+        evidenceReferences
+    };
+}

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

@@ -0,0 +1,247 @@
+import { collectContextCapsuleEvidence } from "./collectContextCapsuleEvidence.js";
+import { collectRetrievalAuditEvidence } from "./collectRetrievalAuditEvidence.js";
+import { collectFullWorkflowLibraryEvidence, collectWorkflowInstructionPacketEvidence } from "./collectWorkflowInstructionEvidence.js";
+import { matchStageContextExpectations } from "./matchStageContextExpectations.js";
+import { calculateAllowedEvidenceCoverage, calculateForbiddenEvidenceInclusion, calculateIrrelevantFileInclusion, calculateIrrelevantInstructionInclusion, calculateRequiredEvidenceRecall, calculateRequiredProvenanceRecall } from "./calculateExpectationMetrics.js";
+import { calculateContextCapsuleResponsibilityMappingMetric, calculateRetrievalAuditResponsibilityMappingMetric } from "./calculateResponsibilityMappingMetrics.js";
+import { compareExpectedContextCapsuleState, compareExpectedRetrievalAuditState, compareExpectedTargetImmutabilityState, compareExpectedWorkflowInstructionPacketState } from "./calculateArtifactStateMetrics.js";
+import { calculateV043ExecutionContextSize } from "./calculateContextSizeMetrics.js";
+function collectExecutionEvidence(execution) {
+    const evidence = [];
+    function pushPairEvidence(pair, labelPrefix) {
+        evidence.push(...collectContextCapsuleEvidence(pair.contextCapsule, `${labelPrefix}.contextCapsule`));
+        if (pair.retrievalAuditRecord) {
+            evidence.push(...collectRetrievalAuditEvidence(pair.retrievalAuditRecord, `${labelPrefix}.retrievalAuditRecord`));
+        }
+    }
+    switch (execution.strategyId) {
+        case "architecture-context-only": {
+            const payload = execution.payload;
+            pushPairEvidence(payload.architecture, "architecture");
+            break;
+        }
+        case "architecture-plus-implementation-refresh": {
+            const payload = execution.payload;
+            pushPairEvidence(payload.architecture, "architecture");
+            pushPairEvidence(payload.implementation, "implementation");
+            break;
+        }
+        case "architecture-plus-implementation-and-test-refresh": {
+            const payload = execution.payload;
+            pushPairEvidence(payload.architecture, "architecture");
+            pushPairEvidence(payload.implementation, "implementation");
+            pushPairEvidence(payload.testImplementation, "testImplementation");
+            break;
+        }
+        case "full-workflow-library": {
+            const payload = execution.payload;
+            evidence.push(...collectFullWorkflowLibraryEvidence(payload.fullWorkflowLibrary, "fullWorkflowLibrary"));
+            break;
+        }
+        case "bounded-workflow-instruction-packet": {
+            const payload = execution.payload;
+            evidence.push(...collectWorkflowInstructionPacketEvidence(payload.workflowInstructionPacket, "workflowInstructionPacket"));
+            break;
+        }
+        case "combined-bounded-stage-context": {
+            const payload = execution.payload;
+            payload.contextArtifacts.forEach((pair, index) => {
+                pushPairEvidence(pair, `contextArtifacts[${index}]`);
+            });
+            evidence.push(...collectWorkflowInstructionPacketEvidence(payload.workflowInstructionPacket, "workflowInstructionPacket"));
+            break;
+        }
+    }
+    return evidence;
+}
+function collectResponsibilityMetrics(execution) {
+    const metrics = [];
+    function pushPairMetrics(pair, labelPrefix) {
+        metrics.push(calculateContextCapsuleResponsibilityMappingMetric(pair.contextCapsule, `${labelPrefix}.contextCapsule`));
+        if (pair.retrievalAuditRecord) {
+            metrics.push(calculateRetrievalAuditResponsibilityMappingMetric(pair.retrievalAuditRecord, `${labelPrefix}.retrievalAuditRecord`));
+        }
+    }
+    switch (execution.strategyId) {
+        case "architecture-context-only": {
+            const payload = execution.payload;
+            pushPairMetrics(payload.architecture, "architecture");
+            break;
+        }
+        case "architecture-plus-implementation-refresh": {
+            const payload = execution.payload;
+            pushPairMetrics(payload.architecture, "architecture");
+            pushPairMetrics(payload.implementation, "implementation");
+            break;
+        }
+        case "architecture-plus-implementation-and-test-refresh": {
+            const payload = execution.payload;
+            pushPairMetrics(payload.architecture, "architecture");
+            pushPairMetrics(payload.implementation, "implementation");
+            pushPairMetrics(payload.testImplementation, "testImplementation");
+            break;
+        }
+        case "combined-bounded-stage-context": {
+            const payload = execution.payload;
+            payload.contextArtifacts.forEach((pair, index) => {
+                pushPairMetrics(pair, `contextArtifacts[${index}]`);
+            });
+            break;
+        }
+        case "full-workflow-library":
+        case "bounded-workflow-instruction-packet":
+            break;
+    }
+    return metrics;
+}
+function buildTargetImmutabilityMetric(targetImmutability) {
+    if (targetImmutability === undefined) {
+        return {
+            availability: "unavailable",
+            count: null,
+            evidenceKeys: [],
+            reason: "Target immutability configuration was not supplied for this strategy run."
+        };
+    }
+    if (targetImmutability.availability === "unavailable") {
+        return {
+            availability: "unavailable",
+            count: null,
+            evidenceKeys: [],
+            reason: targetImmutability.reason
+        };
+    }
+    return {
+        availability: "available",
+        count: targetImmutability.comparison.newMutationCount,
+        evidenceKeys: targetImmutability.comparison.mutations.map((mutation) => mutation.id),
+        reason: null
+    };
+}
+function collectStateComparisons(execution, targetImmutability) {
+    const expectedStates = execution.expectations.expectedStates;
+    const comparisons = [];
+    function pushPairComparisons(pair, labelPrefix) {
+        comparisons.push(...compareExpectedContextCapsuleState(expectedStates.contextCapsule, pair.contextCapsule, `${labelPrefix}.contextCapsule`));
+        if (pair.retrievalAuditRecord) {
+            comparisons.push(...compareExpectedRetrievalAuditState(expectedStates.retrievalAuditRecord, pair.retrievalAuditRecord, `${labelPrefix}.retrievalAuditRecord`));
+        }
+    }
+    switch (execution.strategyId) {
+        case "architecture-context-only": {
+            const payload = execution.payload;
+            pushPairComparisons(payload.architecture, "architecture");
+            break;
+        }
+        case "architecture-plus-implementation-refresh": {
+            const payload = execution.payload;
+            pushPairComparisons(payload.architecture, "architecture");
+            pushPairComparisons(payload.implementation, "implementation");
+            break;
+        }
+        case "architecture-plus-implementation-and-test-refresh": {
+            const payload = execution.payload;
+            pushPairComparisons(payload.architecture, "architecture");
+            pushPairComparisons(payload.implementation, "implementation");
+            pushPairComparisons(payload.testImplementation, "testImplementation");
+            break;
+        }
+        case "full-workflow-library":
+            break;
+        case "bounded-workflow-instruction-packet": {
+            const payload = execution.payload;
+            comparisons.push(...compareExpectedWorkflowInstructionPacketState(expectedStates.workflowInstructionPacket, payload.workflowInstructionPacket, "workflowInstructionPacket"));
+            break;
+        }
+        case "combined-bounded-stage-context": {
+            const payload = execution.payload;
+            payload.contextArtifacts.forEach((pair, index) => {
+                pushPairComparisons(pair, `contextArtifacts[${index}]`);
+            });
+            comparisons.push(...compareExpectedWorkflowInstructionPacketState(expectedStates.workflowInstructionPacket, payload.workflowInstructionPacket, "workflowInstructionPacket"));
+            break;
+        }
+    }
+    comparisons.push(...compareExpectedTargetImmutabilityState(expectedStates.targetImmutability, targetImmutability));
+    return comparisons;
+}
+export function evaluateV043StageContextExecution(execution, context) {
+    try {
+        if (execution.status === "invalid-input") {
+            return {
+                status: "not-applicable",
+                strategyId: execution.strategyId,
+                executionStatus: "invalid-input",
+                reason: "Metrics are not applicable because strategy input validation failed."
+            };
+        }
+        if (execution.status === "failed") {
+            return {
+                status: "not-applicable",
+                strategyId: execution.strategyId,
+                executionStatus: "failed",
+                reason: "Metrics are not applicable because strategy execution failed."
+            };
+        }
+        const status = execution.status;
+        if (status === "unavailable") {
+            return {
+                status: "not-applicable",
+                strategyId: execution.strategyId,
+                executionStatus: "unavailable",
+                reason: "Metrics are not applicable because strategy execution is unavailable."
+            };
+        }
+        if (status === "not-applicable") {
+            return {
+                status: "not-applicable",
+                strategyId: execution.strategyId,
+                executionStatus: "not-applicable",
+                reason: "Metrics are not applicable to this strategy execution."
+            };
+        }
+        const observedEvidence = collectExecutionEvidence(execution);
+        const expectationMatches = matchStageContextExpectations(execution.expectations, observedEvidence);
+        const metrics = {
+            requiredEvidenceRecall: calculateRequiredEvidenceRecall(expectationMatches),
+            allowedEvidenceCoverage: calculateAllowedEvidenceCoverage(expectationMatches),
+            forbiddenEvidenceInclusion: calculateForbiddenEvidenceInclusion(expectationMatches),
+            irrelevantFileInclusion: calculateIrrelevantFileInclusion(execution.expectations, observedEvidence),
+            irrelevantInstructionInclusion: calculateIrrelevantInstructionInclusion(execution.expectations, observedEvidence),
+            requiredProvenanceRecall: calculateRequiredProvenanceRecall(expectationMatches),
+            responsibilityMappingCompleteness: collectResponsibilityMetrics(execution),
+            stateComparisons: collectStateComparisons(execution, context?.targetImmutability),
+            contextSize: calculateV043ExecutionContextSize(execution),
+            consideredButUnselectedReads: {
+                availability: "unavailable",
+                count: null,
+                evidenceKeys: [],
+                reason: "The published upstream artifacts do not expose considered-but-unselected reads."
+            },
+            unnecessaryReads: {
+                availability: "unavailable",
+                count: null,
+                evidenceKeys: [],
+                reason: "The published upstream artifacts do not expose unnecessary-read evidence."
+            },
+            targetImmutability: buildTargetImmutabilityMetric(context?.targetImmutability)
+        };
+        return {
+            status: "completed",
+            strategyId: execution.strategyId,
+            executionStatus: "completed",
+            expectationMatches,
+            observedEvidence,
+            metrics,
+            warnings: []
+        };
+    }
+    catch {
+        return {
+            status: "failed",
+            strategyId: execution.strategyId,
+            executionStatus: execution.status,
+            reason: "Unexpected v0.4.3 stage-context metric evaluation failure."
+        };
+    }
+}

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

@@ -0,0 +1,17 @@
+export { buildStageContextExpectationTargetKey } from "./targetKeys.js";
+export { collectContextCapsuleEvidence } from "./collectContextCapsuleEvidence.js";
+export { collectRetrievalAuditEvidence } from "./collectRetrievalAuditEvidence.js";
+export { collectFullWorkflowLibraryEvidence, collectWorkflowInstructionPacketEvidence } from "./collectWorkflowInstructionEvidence.js";
+export { matchStageContextExpectations } from "./matchStageContextExpectations.js";
+export { calculateAllowedEvidenceCoverage, calculateForbiddenEvidenceInclusion, calculateIrrelevantFileInclusion, calculateIrrelevantInstructionInclusion, calculateRequiredEvidenceRecall, calculateRequiredProvenanceRecall } from "./calculateExpectationMetrics.js";
+export { compareExpectedContextCapsuleState, compareExpectedRetrievalAuditState, compareExpectedTargetImmutabilityState, compareExpectedWorkflowInstructionPacketState } from "./calculateArtifactStateMetrics.js";
+export { calculateContextCapsuleResponsibilityMappingMetric, calculateRetrievalAuditResponsibilityMappingMetric } from "./calculateResponsibilityMappingMetrics.js";
+export { calculateV043ExecutionContextSize } from "./calculateContextSizeMetrics.js";
+export { evaluateV043StageContextExecution } from "./evaluateV043StageContextExecution.js";
+export { collectSelectedOwnerEvidence, calculateOwnerMetrics } from "./calculateOwnerMetrics.js";
+export { calculateAllocationFactsForGroups, calculateRequiredEvidenceOmitted, findAllocationExpectationForGroup } from "./calculateAllocationMetrics.js";
+export { classifyTruncationRecord, classifyTruncationRecords } from "./calculateTruncationClassification.js";
+export { calculateSupplementalRawAgreement } from "./calculateSupplementalRawAgreement.js";
+export { calculateReadinessStructuralAgreement, calculateReadinessDecisionAgreement, calculateInvalidReady, calculateValidBlocked, calculateReadinessAgreementMetrics } from "./calculateReadinessAgreement.js";
+export { calculateCriticalityMetrics } from "./calculateCriticalityMetrics.js";
+export { evaluateProducerReadinessBridge, buildProducerReadinessBridgeInputFromCombinedPayload } from "./evaluateProducerReadinessBridge.js";

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

@@ -0,0 +1,38 @@
+import { buildStageContextExpectationTargetKey } from "./targetKeys.js";
+function dedupeStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        result.push(value);
+    }
+    return result;
+}
+export function matchStageContextExpectations(expectations, observedEvidence) {
+    return expectations.expectedEvidence.map((item) => {
+        const targetKey = buildStageContextExpectationTargetKey(item);
+        const observedMatches = observedEvidence.filter((evidence) => evidence.sourceArtifact === item.sourceArtifact && evidence.category === item.category && evidence.targetKey === targetKey);
+        const matchedSourceInstances = dedupeStrings(observedMatches.map((evidence) => evidence.sourceInstance));
+        const matchedSourceFieldPaths = dedupeStrings(observedMatches.map((evidence) => evidence.sourceFieldPath));
+        const hasMatch = observedMatches.length > 0;
+        let outcome;
+        if (item.inclusion === "forbidden") {
+            outcome = hasMatch ? "violated" : "matched";
+        }
+        else {
+            outcome = hasMatch ? "matched" : "missing";
+        }
+        return {
+            expectationId: item.expectationId,
+            inclusion: item.inclusion,
+            sourceArtifact: item.sourceArtifact,
+            category: item.category,
+            targetKey,
+            outcome,
+            matchedSourceInstances,
+            matchedSourceFieldPaths
+        };
+    });
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,35 @@
+export function buildStageContextExpectationTargetKey(item) {
+    switch (item.category) {
+        case "file":
+        case "test-file":
+        case "fixture":
+        case "factory":
+        case "mock":
+        case "setup-file":
+        case "test-configuration":
+            return `${item.sourceArtifact}|${item.category}|path:${item.match.path}`;
+        case "symbol":
+        case "contract":
+        case "validator":
+        case "constant":
+        case "error":
+        case "schema-or-serializer":
+            return `${item.sourceArtifact}|${item.category}|symbolId:${item.match.symbolId}`;
+        case "source-range":
+            return `context-capsule|source-range|filePath:${item.match.filePath}|startLine:${item.match.startLine}|endLine:${item.match.endLine}`;
+        case "production-responsibility":
+            return `${item.sourceArtifact}|production-responsibility|responsibilityId:${item.match.responsibilityId}`;
+        case "package-script":
+            return `context-capsule|package-script|name:${item.match.name}`;
+        case "test-command":
+            return `context-capsule|test-command|commandText:${item.match.commandText}`;
+        case "workflow":
+        case "stage":
+        case "command":
+        case "rule":
+        case "report-contract":
+            return `${item.sourceArtifact}|${item.category}|id:${item.match.id}`;
+        case "provenance":
+            return `${item.sourceArtifact}|provenance|evidenceId:${item.match.evidenceId}`;
+    }
+}

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

@@ -0,0 +1 @@
+export {};