@duckcodeailabs/dql-agent 1.10.1 → 1.10.3

package/dist/metadata/catalog.js

@@ -888,6 +888,33 @@ export function buildMetadataSnapshot(projectRoot, manifest, semanticLayer, skil
  * Acceptance: CONTRACT-002, AGT-018.
  */
 function addCertifiedBlockAnalyticalCapabilities(objects) {
+    // Existing certified blocks can carry the pre-ID-001 domain-scoped member
+    // identities. Canonicalize those aliases only when exactly one semantic
+    // object owns them; repeated leaf aliases intentionally fail closed.
+    const semanticIdentityTargets = new Map();
+    for (const object of objects.values()) {
+        if (!object.objectType.startsWith('semantic_'))
+            continue;
+        const payload = object.payload ?? {};
+        const canonicalIdentity = object.fullName ?? object.name;
+        for (const identity of uniqueNonBlank([
+            canonicalIdentity,
+            stringValue(payload.qualifiedId),
+            stringValue(payload.registryQualifiedId),
+            stringValue(payload.sourceNativeId),
+            ...metadataStringArray(payload.aliases),
+        ])) {
+            const targets = semanticIdentityTargets.get(identity) ?? new Set();
+            targets.add(canonicalIdentity);
+            semanticIdentityTargets.set(identity, targets);
+        }
+    }
+    const canonicalizeSemanticRef = (identity) => {
+        const targets = semanticIdentityTargets.get(identity);
+        if (!targets)
+            return identity;
+        return targets.size === 1 ? [...targets][0] : undefined;
+    };
     const semanticCapabilities = [...objects.values()].flatMap((object) => {
         if (object.objectType !== "semantic_metric")
             return [];
@@ -923,15 +950,22 @@ function addCertifiedBlockAnalyticalCapabilities(objects) {
         if (metrics.length !== 1)
             continue;
         const semantic = metrics[0];
-        const grain = stringValue(payload.grain);
+        const authoredGrain = stringValue(payload.grain);
+        const grain = authoredGrain ? canonicalizeSemanticRef(authoredGrain) : undefined;
         if (!grain || !semantic.capability.resultGrainIds.includes(grain))
             continue;
-        const groupedRefs = uniqueNonBlank([
+        const authoredGroupedRefs = uniqueNonBlank([
             ...metadataStringArray(payload.dimensions),
             ...metadataStringArray(payload.dimensionsRef),
         ]);
-        const filterRefs = uniqueNonBlank(metadataStringArray(payload.allowedFilters));
-        const declaredRefs = new Set([...groupedRefs, ...filterRefs]);
+        const authoredFilterRefs = uniqueNonBlank(metadataStringArray(payload.allowedFilters));
+        const groupedRefs = authoredGroupedRefs.map(canonicalizeSemanticRef);
+        const filterRefs = authoredFilterRefs.map(canonicalizeSemanticRef);
+        if (groupedRefs.some((ref) => !ref) || filterRefs.some((ref) => !ref))
+            continue;
+        const canonicalGroupedRefs = groupedRefs.filter((ref) => Boolean(ref));
+        const canonicalFilterRefs = filterRefs.filter((ref) => Boolean(ref));
+        const declaredRefs = new Set([...canonicalGroupedRefs, ...canonicalFilterRefs]);
         const capabilityDimensionIds = new Set(semantic.capability.dimensions.map((item) => item.dimensionId));
         const capabilityTimeIds = new Set(semantic.capability.timeDimensions.map((item) => item.dimensionId));
         if ([...declaredRefs].some((id) => !capabilityDimensionIds.has(id) && !capabilityTimeIds.has(id)))
@@ -939,14 +973,14 @@ function addCertifiedBlockAnalyticalCapabilities(objects) {
         const dimensions = semantic.capability.dimensions.flatMap((dimension) => {
             if (!declaredRefs.has(dimension.dimensionId))
                 return [];
-            const roles = dimension.supportedRoles.filter((role) => (role === "filter" && filterRefs.includes(dimension.dimensionId)) ||
+            const roles = dimension.supportedRoles.filter((role) => (role === "filter" && canonicalFilterRefs.includes(dimension.dimensionId)) ||
                 (role === "group_by" &&
-                    groupedRefs.includes(dimension.dimensionId)) ||
+                    canonicalGroupedRefs.includes(dimension.dimensionId)) ||
                 (role === "display" &&
-                    groupedRefs.includes(dimension.dimensionId)) ||
+                    canonicalGroupedRefs.includes(dimension.dimensionId)) ||
                 (role === "rank_entity" &&
                     payload.pattern === "ranking" &&
-                    groupedRefs.includes(dimension.dimensionId)));
+                    canonicalGroupedRefs.includes(dimension.dimensionId)));
             return roles.length > 0
                 ? [{ ...dimension, supportedRoles: roles }]
                 : [];
@@ -961,9 +995,9 @@ function addCertifiedBlockAnalyticalCapabilities(objects) {
             !outputs.kinds.includes("metric_value"))
             continue;
         const operations = [];
-        if (filterRefs.length > 0)
+        if (canonicalFilterRefs.length > 0)
             operations.push("filter");
-        if (groupedRefs.some((id) => capabilityDimensionIds.has(id)))
+        if (canonicalGroupedRefs.some((id) => capabilityDimensionIds.has(id)))
             operations.push("group");
         if (payload.pattern === "trend")
             operations.push("trend");
@@ -978,8 +1012,8 @@ function addCertifiedBlockAnalyticalCapabilities(objects) {
                 blockId,
                 metricRefs,
                 grain,
-                groupedRefs,
-                filterRefs,
+                groupedRefs: canonicalGroupedRefs,
+                filterRefs: canonicalFilterRefs,
                 outputs,
             }));
         const capability = {
@@ -2530,6 +2564,9 @@ function isQualifiedDqlModelingNode(node) {
 }
 function qualifiedIdentityFromKGNode(node) {
     const payload = node.payload ?? {};
+    const registryIdentity = stringValue(payload.registryQualifiedId);
+    if (registryIdentity)
+        return registryIdentity;
     const explicit = stringValue(payload.qualifiedId);
     if (explicit)
         return explicit;