agent-inspect 6.31.21 → 6.31.22

package/packages/cli/dist/index.cjs

@@ -8114,6 +8114,121 @@ var init_tool_arguments = __esm({
   }
 });
 
+// packages/core/src/persisted/delivery-identity.ts
+function stripReaderDeliveryDiscriminator(eventId) {
+  if (!SYNTHETIC_DELIVERY_ID.test(eventId)) return eventId;
+  return eventId.replace(/:\d+$/, "");
+}
+function canonicalDigest(value) {
+  if (value === void 0) return null;
+  const encoded = encodeCanonicalStructured(value);
+  return encoded.ok ? encoded.value : `unencodable:${encoded.code}`;
+}
+function capturedContentDigest(attributes) {
+  if (!attributes || typeof attributes !== "object") {
+    return { args: null, result: null };
+  }
+  const nested = attributes.metadata && typeof attributes.metadata === "object" ? attributes.metadata : void 0;
+  const args = attributes.arguments ?? attributes.args ?? attributes.input ?? nested?.arguments ?? nested?.args ?? nested?.input;
+  const result = attributes.result ?? attributes.output ?? attributes.response ?? nested?.result ?? nested?.output ?? nested?.response;
+  return {
+    args: args === void 0 ? null : canonicalDigest(args),
+    result: result === void 0 ? null : canonicalDigest(result)
+  };
+}
+function timeKey(fields) {
+  if (typeof fields.startedAt === "string" && fields.startedAt.trim() !== "") {
+    return fields.startedAt;
+  }
+  if (typeof fields.timestamp === "string" && fields.timestamp.trim() !== "") {
+    return fields.timestamp;
+  }
+  if (typeof fields.timestamp === "number" && Number.isFinite(fields.timestamp)) {
+    return String(fields.timestamp);
+  }
+  return null;
+}
+function deliverySemanticFingerprint(fields) {
+  const content = capturedContentDigest(fields.attributes);
+  return JSON.stringify({
+    stableEventId: stripReaderDeliveryDiscriminator(fields.eventId),
+    runId: fields.runId,
+    kind: fields.kind,
+    name: fields.name,
+    status: fields.status ?? null,
+    parentId: fields.parentId ?? null,
+    sourceType: fields.sourceType ?? null,
+    time: timeKey(fields),
+    operationId: fields.operationId ?? null,
+    attemptId: fields.attemptId ?? null,
+    attemptNumber: fields.attemptNumber ?? null,
+    retryOf: fields.retryOf ?? null,
+    argsDigest: content.args,
+    resultDigest: content.result
+  });
+}
+function identityFieldsFromAttributes(attributes) {
+  if (!attributes || typeof attributes !== "object") {
+    return {
+      operationId: null,
+      attemptId: null,
+      attemptNumber: null,
+      retryOf: null
+    };
+  }
+  const nested = attributes.metadata && typeof attributes.metadata === "object" && !Array.isArray(attributes.metadata) ? attributes.metadata : void 0;
+  const pickString3 = (key) => {
+    const direct = attributes[key];
+    if (typeof direct === "string" && direct.trim() !== "") return direct.trim();
+    const nestedValue = nested?.[key];
+    if (typeof nestedValue === "string" && nestedValue.trim() !== "") {
+      return nestedValue.trim();
+    }
+    return null;
+  };
+  const pickNumber2 = () => {
+    const direct = attributes.attemptNumber ?? attributes.attempt;
+    if (typeof direct === "number" && Number.isFinite(direct)) return direct;
+    const nestedValue = nested?.attemptNumber ?? nested?.attempt;
+    if (typeof nestedValue === "number" && Number.isFinite(nestedValue)) {
+      return nestedValue;
+    }
+    return null;
+  };
+  return {
+    operationId: pickString3("operationId"),
+    attemptId: pickString3("attemptId"),
+    retryOf: pickString3("retryOf"),
+    attemptNumber: pickNumber2()
+  };
+}
+function hasDeliveryConflictMarker(attributes) {
+  return attributes?.[DELIVERY_CONFLICT_ATTR] === true;
+}
+function stampDeliveryConflict(event) {
+  return {
+    ...event,
+    attributes: {
+      ...event.attributes ?? {},
+      [DELIVERY_CONFLICT_ATTR]: true
+    }
+  };
+}
+var DELIVERY_CONFLICT_ATTR, IDENTITY_CONFLICT_ATTR, SYNTHETIC_DELIVERY_ID;
+var init_delivery_identity = __esm({
+  "packages/core/src/persisted/delivery-identity.ts"() {
+    init_canonical_equality();
+    DELIVERY_CONFLICT_ATTR = "agent_inspect.delivery_conflict";
+    IDENTITY_CONFLICT_ATTR = {
+      operationId: "agent_inspect.identity_conflict.operation_id",
+      attemptId: "agent_inspect.identity_conflict.attempt_id",
+      retryOf: "agent_inspect.identity_conflict.retry_of",
+      attemptNumber: "agent_inspect.identity_conflict.attempt_number"
+    };
+    SYNTHETIC_DELIVERY_ID = /^(?:manual|inspect):[A-Za-z0-9_-]+:[A-Za-z0-9_-]+:[A-Za-z0-9_-]+:\d+$/;
+  }
+});
+
 // packages/core/src/checks/retry-safety.ts
 function fail2(ruleId, message, evidence, expected, actual) {
   return {
@@ -8169,7 +8284,7 @@ function attemptIdOf(event) {
 }
 function countOperationAttempts(members) {
   const identified = /* @__PURE__ */ new Set();
-  let unidentified = 0;
+  const unidentifiedFingerprints = /* @__PURE__ */ new Set();
   for (const event of members) {
     if (event.kind !== "TOOL" && event.kind !== "LLM") continue;
     const id = attemptIdOf(event);
@@ -8177,13 +8292,13 @@ function countOperationAttempts(members) {
       identified.add(id);
       continue;
     }
-    unidentified += 1;
+    unidentifiedFingerprints.add(redeliveryFingerprint(event));
   }
   if (identified.size > 0) {
-    return identified.size + unidentified;
+    return identified.size + unidentifiedFingerprints.size;
   }
   const numbered = /* @__PURE__ */ new Set();
-  let unnumbered = 0;
+  const unnumberedFingerprints = /* @__PURE__ */ new Set();
   for (const event of members) {
     if (event.kind !== "TOOL" && event.kind !== "LLM") continue;
     const num2 = attemptNumberOf(event);
@@ -8191,12 +8306,12 @@ function countOperationAttempts(members) {
       numbered.add(num2);
       continue;
     }
-    unnumbered += 1;
+    unnumberedFingerprints.add(redeliveryFingerprint(event));
   }
   if (numbered.size > 0) {
-    return numbered.size + unnumbered;
+    return numbered.size + unnumberedFingerprints.size;
   }
-  return unnumbered;
+  return unnumberedFingerprints.size;
 }
 function classifyRetryAttempt(event, priorOrdered, allMembers) {
   const workflow = workflowFor(event);
@@ -8248,19 +8363,48 @@ function classifyRetryAttempt(event, priorOrdered, allMembers) {
 }
 function redeliveryFingerprint(event) {
   const workflow = workflowFor(event);
-  const stableEventId = (event.eventId ?? "").replace(/:\d+$/, "");
-  return JSON.stringify({
-    stableEventId,
+  return deliverySemanticFingerprint({
+    eventId: event.eventId ?? "",
     runId: event.runId,
     kind: event.kind,
     name: event.name,
     status: event.status,
+    parentId: event.parentId,
+    timestamp: event.timestamp,
+    startedAt: event.startedAt,
+    sourceType: event.source?.type,
+    attributes: event.attributes && typeof event.attributes === "object" ? event.attributes : void 0,
     operationId: workflow.operationId ?? null,
     attemptId: workflow.attemptId ?? null,
     attemptNumber: workflow.attemptNumber ?? null,
     retryOf: workflow.retryOf ?? null
   });
 }
+function identityValuesEqual(a, b) {
+  if (typeof a === "number" && typeof b === "number") {
+    return Number.isFinite(a) && Number.isFinite(b) && a === b;
+  }
+  if (typeof a === "string" && typeof b === "string") {
+    return a.trim() === b.trim();
+  }
+  return a === b;
+}
+function directNestedIdentityConflicts(event) {
+  const attrs = event.attributes;
+  if (!attrs || typeof attrs !== "object") return [];
+  const nested = attrs.metadata && typeof attrs.metadata === "object" && !Array.isArray(attrs.metadata) ? attrs.metadata : void 0;
+  if (!nested) return [];
+  const conflicts = [];
+  for (const key of IDENTITY_KEYS) {
+    const direct = attrs[key];
+    const nestedValue = nested[key];
+    if (direct === void 0 || nestedValue === void 0) continue;
+    if (!identityValuesEqual(direct, nestedValue)) {
+      conflicts.push(key);
+    }
+  }
+  return conflicts;
+}
 function hasConflictingAttemptIdReuse(members) {
   const byAttempt = /* @__PURE__ */ new Map();
   for (const event of members) {
@@ -8276,6 +8420,31 @@ function hasConflictingAttemptIdReuse(members) {
   }
   return false;
 }
+function hasConflictingEventIdReuse(members) {
+  const byEventId = /* @__PURE__ */ new Map();
+  for (const event of members) {
+    if (event.kind !== "TOOL" && event.kind !== "LLM") continue;
+    const eventId = event.eventId;
+    if (!eventId) continue;
+    if (hasDeliveryConflictMarker(event.attributes)) {
+      return true;
+    }
+    const fingerprints = byEventId.get(eventId) ?? /* @__PURE__ */ new Set();
+    fingerprints.add(redeliveryFingerprint(event));
+    byEventId.set(eventId, fingerprints);
+  }
+  for (const fingerprints of byEventId.values()) {
+    if (fingerprints.size > 1) return true;
+  }
+  return false;
+}
+function hasIdentityRepresentationConflict(members) {
+  for (const event of members) {
+    if (event.kind !== "TOOL" && event.kind !== "LLM") continue;
+    if (directNestedIdentityConflicts(event).length > 0) return true;
+  }
+  return false;
+}
 function evaluateRetrySafetyRules(events, rules, _runEvidence) {
   const findings = [];
   const byOperation = /* @__PURE__ */ new Map();
@@ -8283,13 +8452,14 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
     const workflow = workflowFor(event);
     const operationId = workflow.operationId;
     if (!operationId) continue;
-    const list2 = byOperation.get(operationId) ?? [];
-    list2.push(event);
-    byOperation.set(operationId, list2);
+    const key = `${event.runId}\0${operationId}`;
+    const group = byOperation.get(key) ?? { operationId, members: [] };
+    group.members.push(event);
+    byOperation.set(key, group);
   }
   if (rules.maxAttempts !== void 0) {
-    for (const [operationId, members] of byOperation) {
-      if (hasConflictingAttemptIdReuse(members)) {
+    for (const { operationId, members } of byOperation.values()) {
+      if (hasConflictingAttemptIdReuse(members) || hasConflictingEventIdReuse(members)) {
         findings.push(
           fail2(
             "contract.retry.duplicate-attempt-id",
@@ -8300,6 +8470,31 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
           )
         );
       }
+      if (hasIdentityRepresentationConflict(members)) {
+        findings.push(
+          fail2(
+            "contract.retry.ambiguous-identity",
+            `Operation ${operationId} has conflicting direct vs nested identity fields; strict identity cannot pass.`,
+            members.slice(0, 4).map(eventEvidence2),
+            "agreeing identity representation",
+            "direct/nested conflict"
+          )
+        );
+      }
+      const toolish = members.filter((event) => event.kind === "TOOL" || event.kind === "LLM");
+      const hasAttemptId = toolish.some((event) => attemptIdOf(event) !== void 0);
+      const missingAttemptId = toolish.some((event) => attemptIdOf(event) === void 0);
+      if (hasAttemptId && missingAttemptId) {
+        findings.push(
+          fail2(
+            "contract.retry.ambiguous-identity",
+            `Operation ${operationId} has partial attempt identity; strict identity conformance cannot pass.`,
+            members.slice(0, 4).map(eventEvidence2),
+            "complete attempt identity",
+            "partial attemptId coverage"
+          )
+        );
+      }
       const count = countOperationAttempts(members);
       if (count > rules.maxAttempts) {
         findings.push(
@@ -8315,7 +8510,7 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
     }
   }
   if (rules.requireTerminalResult) {
-    for (const [operationId, members] of byOperation) {
+    for (const { operationId, members } of byOperation.values()) {
       const hasTerminal = members.some((event) => event.status === "ok" || event.status === "error");
       if (!hasTerminal) {
         findings.push(
@@ -8335,7 +8530,7 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
       const workflow = workflowFor(event);
       const fallbackOf = workflow.fallbackOf;
       if (!fallbackOf) continue;
-      const prior = byOperation.get(fallbackOf) ?? [];
+      const prior = byOperation.get(`${event.runId}\0${fallbackOf}`)?.members ?? [];
       const fallbackStart = eventTime(event);
       const earlierFailure = prior.some(
         (candidate) => candidate.status === "error" && eventTime(candidate) !== "" && fallbackStart !== "" && eventTime(candidate) < fallbackStart
@@ -8362,7 +8557,7 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
     for (const event of toolEvents) {
       const name = resolveCanonicalToolName(event);
       const workflow = workflowFor(event);
-      const key = `${workflow.operationId ?? name}::${name}`;
+      const key = `${event.runId}::${workflow.operationId ?? name}::${name}`;
       const list2 = byToolOp.get(key) ?? [];
       list2.push(event);
       byToolOp.set(key, list2);
@@ -8420,7 +8615,7 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
     }
   }
   if (rules.requireRecoveredFailureVisible) {
-    for (const [operationId, members] of byOperation) {
+    for (const { operationId, members } of byOperation.values()) {
       const ordered = sortByTime(members);
       const toolish = ordered.filter(
         (event) => (event.kind === "TOOL" || event.kind === "LLM") && (event.status === "ok" || event.status === "error")
@@ -8459,10 +8654,13 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
   }
   return findings;
 }
+var IDENTITY_KEYS;
 var init_retry_safety = __esm({
   "packages/core/src/checks/retry-safety.ts"() {
     init_logical_events();
+    init_delivery_identity();
     init_metadata();
+    IDENTITY_KEYS = ["operationId", "attemptId", "retryOf", "attemptNumber"];
   }
 });
 
@@ -8679,14 +8877,7 @@ function attemptIdOf2(event) {
   return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
 }
 function hasDuplicateAttemptIds(members) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const event of members) {
-    const id = attemptIdOf2(event);
-    if (!id) continue;
-    if (seen.has(id)) return true;
-    seen.add(id);
-  }
-  return false;
+  return hasConflictingAttemptIdReuse(members) || hasConflictingEventIdReuse(members);
 }
 function findRetryTarget(members, retryOf) {
   return members.find(
@@ -12898,6 +13089,7 @@ function resolveRunTiming(sorted, status) {
 var TreeBuilder;
 var init_tree_builder = __esm({
   "packages/core/src/logs/tree-builder.ts"() {
+    init_delivery_identity();
     TreeBuilder = class {
       constructor(options) {
         void options?.config;
@@ -12913,7 +13105,47 @@ var init_tree_builder = __esm({
           const sorted = [...runEvents].sort((a, b) => a.timestamp - b.timestamp);
           const nodes = /* @__PURE__ */ new Map();
           for (const e of sorted) {
-            nodes.set(e.eventId, { event: e, children: [], depth: 0 });
+            const existing = nodes.get(e.eventId);
+            if (!existing) {
+              nodes.set(e.eventId, { event: e, children: [], depth: 0 });
+              continue;
+            }
+            const existingAttrs = existing.event.attributes && typeof existing.event.attributes === "object" ? existing.event.attributes : void 0;
+            const nextAttrs = e.attributes && typeof e.attributes === "object" ? e.attributes : void 0;
+            const existingIdentity = identityFieldsFromAttributes(existingAttrs);
+            const nextIdentity = identityFieldsFromAttributes(nextAttrs);
+            const existingFp = deliverySemanticFingerprint({
+              eventId: existing.event.eventId,
+              runId: existing.event.runId,
+              kind: existing.event.kind,
+              name: existing.event.name,
+              status: existing.event.status,
+              parentId: existing.event.parentId,
+              timestamp: existing.event.timestamp,
+              sourceType: existing.event.source?.type,
+              attributes: existingAttrs,
+              ...existingIdentity
+            });
+            const nextFp = deliverySemanticFingerprint({
+              eventId: e.eventId,
+              runId: e.runId,
+              kind: e.kind,
+              name: e.name,
+              status: e.status,
+              parentId: e.parentId,
+              timestamp: e.timestamp,
+              sourceType: e.source?.type,
+              attributes: nextAttrs,
+              ...nextIdentity
+            });
+            if (existingFp === nextFp) {
+              continue;
+            }
+            nodes.set(e.eventId, {
+              event: stampDeliveryConflict(e),
+              children: [],
+              depth: 0
+            });
           }
           const { roots, summary } = linkNodesVisibilityFirst(nodes);
           const confidenceBreakdown = {
@@ -14190,6 +14422,12 @@ function promoteAgentInspectWorkflowIdentity(attributes, pathPrefix) {
     ["agent_inspect.retry_of", "retryOf", "string"],
     ["agent_inspect.attempt_number", "attemptNumber", "int"]
   ];
+  const conflictMapping = [
+    ["agent_inspect.identity_conflict.operation_id", "operationId", "string"],
+    ["agent_inspect.identity_conflict.attempt_id", "attemptId", "string"],
+    ["agent_inspect.identity_conflict.retry_of", "retryOf", "string"],
+    ["agent_inspect.identity_conflict.attempt_number", "attemptNumber", "int"]
+  ];
   const metadata = attributes.metadata && typeof attributes.metadata === "object" && !Array.isArray(attributes.metadata) ? { ...attributes.metadata } : {};
   for (const [dotted, camel, kind] of mapping) {
     const raw = attributes[dotted];
@@ -14241,6 +14479,46 @@ function promoteAgentInspectWorkflowIdentity(attributes, pathPrefix) {
     if (direct === void 0) attributes[camel] = promoted;
     if (nested === void 0) metadata[camel] = promoted;
   }
+  for (const [dotted, camel, kind] of conflictMapping) {
+    const raw = attributes[dotted];
+    if (raw === void 0 || raw === null) continue;
+    let alternate;
+    if (kind === "int") {
+      const n = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : NaN;
+      if (!Number.isFinite(n) || n < 1) {
+        warnings.push({
+          code: "otlp_identity_invalid",
+          message: `Ignoring invalid ${dotted} identity conflict value.`,
+          severity: "warning",
+          field: `${pathPrefix}.${dotted}`
+        });
+        continue;
+      }
+      alternate = Math.trunc(n);
+    } else if (typeof raw === "string" && raw.trim() !== "") {
+      alternate = raw.trim();
+    } else {
+      warnings.push({
+        code: "otlp_identity_invalid",
+        message: `Ignoring non-string ${dotted} identity conflict value.`,
+        severity: "warning",
+        field: `${pathPrefix}.${dotted}`
+      });
+      continue;
+    }
+    const preferred = attributes[camel];
+    if (preferred !== void 0 && preferred !== alternate) {
+      metadata[camel] = alternate;
+      warnings.push({
+        code: "otlp_identity_conflict",
+        message: `Conflicting ${camel}: attributes.${camel} vs nested alternate from ${dotted}; retaining both.`,
+        severity: "warning",
+        field: `${pathPrefix}.${dotted}`
+      });
+    } else if (preferred === void 0) {
+      metadata[camel] = alternate;
+    }
+  }
   if (Object.keys(metadata).length > 0) {
     attributes.metadata = metadata;
   }
@@ -16980,7 +17258,7 @@ var init_src = __esm({
 });
 
 // package.json
-var version = "6.31.21";
+var version = "6.31.22";
 
 // packages/cli/src/list.ts
 init_advanced();
@@ -19588,6 +19866,7 @@ function exportOpenInference(tree, options) {
 }
 
 // packages/core/src/exporters/otlp-json-exporter.ts
+init_delivery_identity();
 init_helpers();
 var OTLP_STATUS_CODE_UNSET = 0;
 var OTLP_STATUS_CODE_OK = 1;
@@ -19638,43 +19917,81 @@ var STRUCTURAL_IDENTITY_KEYS = [
   "attemptNumber",
   "attempt"
 ];
-function pickBoundedIdentityString(bag, key, maxLen) {
+function nestedBag(bag) {
   if (!bag || typeof bag !== "object") return void 0;
-  const direct = bag[key];
-  if (typeof direct === "string" && direct.trim() !== "") {
-    return direct.trim().slice(0, maxLen);
-  }
-  const nested = bag.metadata && typeof bag.metadata === "object" ? bag.metadata[key] : void 0;
-  if (typeof nested === "string" && nested.trim() !== "") {
-    return nested.trim().slice(0, maxLen);
-  }
-  return void 0;
+  const nested = bag.metadata;
+  if (!nested || typeof nested !== "object" || Array.isArray(nested)) return void 0;
+  return nested;
+}
+function pickBoundedIdentityString(bag, key, maxLen) {
+  if (!bag || typeof bag !== "object") return {};
+  const directRaw = bag[key];
+  const nestedRaw = nestedBag(bag)?.[key];
+  const direct = typeof directRaw === "string" && directRaw.trim() !== "" ? directRaw.trim().slice(0, maxLen) : void 0;
+  const nested = typeof nestedRaw === "string" && nestedRaw.trim() !== "" ? nestedRaw.trim().slice(0, maxLen) : void 0;
+  if (direct !== void 0 && nested !== void 0 && direct !== nested) {
+    return { value: direct, conflictAlternate: nested };
+  }
+  if (direct !== void 0) return { value: direct };
+  if (nested !== void 0) return { value: nested };
+  return {};
 }
 function pickBoundedIdentityNumber(bag, key) {
-  if (!bag || typeof bag !== "object") return void 0;
-  const direct = bag[key];
-  if (typeof direct === "number" && Number.isFinite(direct)) return direct;
-  const nested = bag.metadata && typeof bag.metadata === "object" ? bag.metadata[key] : void 0;
-  if (typeof nested === "number" && Number.isFinite(nested)) return nested;
-  return void 0;
+  if (!bag || typeof bag !== "object") return {};
+  const directRaw = bag[key];
+  const nestedRaw = nestedBag(bag)?.[key];
+  const direct = typeof directRaw === "number" && Number.isFinite(directRaw) ? directRaw : void 0;
+  const nested = typeof nestedRaw === "number" && Number.isFinite(nestedRaw) ? nestedRaw : void 0;
+  if (direct !== void 0 && nested !== void 0 && direct !== nested) {
+    return { value: direct, conflictAlternate: nested };
+  }
+  if (direct !== void 0) return { value: direct };
+  if (nested !== void 0) return { value: nested };
+  return {};
 }
 function appendStructuralIdentityAttrs(attrs, meta2, maxLen) {
+  const conflicts = [];
   const operationId = pickBoundedIdentityString(meta2, "operationId", maxLen);
-  if (operationId !== void 0) {
-    attrs.push(stringAttr2("agent_inspect.operation_id", operationId));
+  if (operationId.value !== void 0) {
+    attrs.push(stringAttr2("agent_inspect.operation_id", operationId.value));
+  }
+  if (operationId.conflictAlternate !== void 0) {
+    attrs.push(
+      stringAttr2(IDENTITY_CONFLICT_ATTR.operationId, operationId.conflictAlternate)
+    );
+    conflicts.push("operationId");
   }
   const attemptId = pickBoundedIdentityString(meta2, "attemptId", maxLen);
-  if (attemptId !== void 0) {
-    attrs.push(stringAttr2("agent_inspect.attempt_id", attemptId));
+  if (attemptId.value !== void 0) {
+    attrs.push(stringAttr2("agent_inspect.attempt_id", attemptId.value));
+  }
+  if (attemptId.conflictAlternate !== void 0) {
+    attrs.push(stringAttr2(IDENTITY_CONFLICT_ATTR.attemptId, attemptId.conflictAlternate));
+    conflicts.push("attemptId");
   }
   const retryOf = pickBoundedIdentityString(meta2, "retryOf", maxLen);
-  if (retryOf !== void 0) {
-    attrs.push(stringAttr2("agent_inspect.retry_of", retryOf));
+  if (retryOf.value !== void 0) {
+    attrs.push(stringAttr2("agent_inspect.retry_of", retryOf.value));
   }
-  const attemptNumber2 = pickBoundedIdentityNumber(meta2, "attemptNumber") ?? pickBoundedIdentityNumber(meta2, "attempt");
-  if (attemptNumber2 !== void 0) {
-    attrs.push(intAttr("agent_inspect.attempt_number", attemptNumber2));
+  if (retryOf.conflictAlternate !== void 0) {
+    attrs.push(stringAttr2(IDENTITY_CONFLICT_ATTR.retryOf, retryOf.conflictAlternate));
+    conflicts.push("retryOf");
+  }
+  const attemptNumberPrimary = pickBoundedIdentityNumber(meta2, "attemptNumber");
+  const attemptNumber2 = attemptNumberPrimary.value !== void 0 || attemptNumberPrimary.conflictAlternate !== void 0 ? attemptNumberPrimary : pickBoundedIdentityNumber(meta2, "attempt");
+  if (attemptNumber2.value !== void 0) {
+    attrs.push(intAttr("agent_inspect.attempt_number", attemptNumber2.value));
+  }
+  if (attemptNumber2.conflictAlternate !== void 0) {
+    attrs.push(
+      intAttr(IDENTITY_CONFLICT_ATTR.attemptNumber, attemptNumber2.conflictAlternate)
+    );
+    conflicts.push("attemptNumber");
   }
+  if (meta2?.[DELIVERY_CONFLICT_ATTR] === true) {
+    attrs.push(boolAttr(DELIVERY_CONFLICT_ATTR, true));
+  }
+  return conflicts;
 }
 function resolveSpanTimes(ev) {
   const startedAtMs = typeof ev.attributes?.startedAtMs === "number" && Number.isFinite(ev.attributes.startedAtMs) ? ev.attributes.startedAtMs : void 0;
@@ -19697,7 +20014,8 @@ function exportOtlpJson(tree, options) {
     "OTLP JSON export uses OTel GenAI-aligned attributes where applicable; experimental until verified against specific collectors.",
     "Not OTLP gRPC/protobuf \u2014 JSON mapping only. Generated locally; no network upload.",
     "Status and span kind use OTLP numeric enums (StatusCode 0/1/2, SpanKind INTERNAL=1).",
-    "When present on source events, operationId/attemptId/retryOf/attemptNumber are emitted as bounded agent_inspect.* identity attributes (not a broad attribute dump)."
+    "When present on source events, operationId/attemptId/retryOf/attemptNumber are emitted as bounded agent_inspect.* identity attributes (not a broad attribute dump).",
+    "When direct and nested identity disagree, export prefers direct for non-strict consumers and emits agent_inspect.identity_conflict.* for the nested alternate; this does not certify conflicting identity."
   ];
   const traceId = hexFrom2(`trace:${tree.runId}`, 16);
   const includeAttributes = options?.includeAttributes ?? false;
@@ -19745,11 +20063,16 @@ function exportOtlpJson(tree, options) {
       if (typeof inp === "number") attrs.push(intAttr("gen_ai.usage.input_tokens", inp));
       if (typeof outp === "number") attrs.push(intAttr("gen_ai.usage.output_tokens", outp));
     }
-    appendStructuralIdentityAttrs(
+    const identityConflicts = appendStructuralIdentityAttrs(
       attrs,
       meta2 && typeof meta2 === "object" ? meta2 : void 0,
       maxLen
     );
+    if (identityConflicts.length > 0) {
+      warnings.push(
+        `Identity representation conflict on event ${ev.eventId}: ${identityConflicts.join(", ")} (direct preferred; nested retained on agent_inspect.identity_conflict.*).`
+      );
+    }
     if (includeAttributes && meta2 && typeof meta2 === "object") {
       const skipKeys = /* @__PURE__ */ new Set([
         "tokens",