agent-inspect 6.18.0 → 6.19.1

package/packages/cli/dist/index.cjs

@@ -164,6 +164,12 @@ var init_redactor = __esm({
   }
 });
 
+// packages/core/src/safety/credential-value-patterns.ts
+var init_credential_value_patterns = __esm({
+  "packages/core/src/safety/credential-value-patterns.ts"() {
+  }
+});
+
 // packages/core/src/redaction-profiles.ts
 function resolveRedactionProfile(profile = "local") {
   switch (profile) {
@@ -1110,6 +1116,7 @@ var init_storage = __esm({
 var init_trace_event_safety = __esm({
   "packages/core/src/trace-event-safety.ts"() {
     init_redactor();
+    init_credential_value_patterns();
     init_redaction_profiles();
     init_storage();
     init_persisted_inspect_event();
@@ -2041,6 +2048,58 @@ async function extractMetadata(filePath, _quickScan) {
 function isNonNegativeFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
+function resolveParentStepId(step, steps) {
+  const parentId = step.parentId;
+  if (typeof parentId !== "string" || parentId.trim() === "") {
+    return void 0;
+  }
+  return steps.has(parentId) ? parentId : void 0;
+}
+function computeStepDepth(stepId, steps, depthCache) {
+  const cached2 = depthCache.get(stepId);
+  if (cached2 !== void 0) return cached2;
+  const ancestry = [];
+  const ancestryIndexes = /* @__PURE__ */ new Map();
+  let currentStepId = stepId;
+  let resolvedDepth;
+  while (resolvedDepth === void 0) {
+    const cachedDepth = depthCache.get(currentStepId);
+    if (cachedDepth !== void 0) {
+      resolvedDepth = cachedDepth;
+      continue;
+    }
+    const cycleStart = ancestryIndexes.get(currentStepId);
+    if (cycleStart !== void 0) {
+      const cycleStepIds = ancestry.splice(cycleStart);
+      for (const cycleStepId of cycleStepIds) {
+        depthCache.set(cycleStepId, ROOT_STEP_DEPTH);
+      }
+      resolvedDepth = ROOT_STEP_DEPTH;
+      continue;
+    }
+    const currentStep = steps.get(currentStepId);
+    if (!currentStep) {
+      resolvedDepth = ROOT_STEP_DEPTH;
+      continue;
+    }
+    ancestryIndexes.set(currentStepId, ancestry.length);
+    ancestry.push(currentStepId);
+    const parentStepId = resolveParentStepId(currentStep, steps);
+    if (parentStepId === void 0) {
+      ancestry.pop();
+      depthCache.set(currentStepId, ROOT_STEP_DEPTH);
+      resolvedDepth = ROOT_STEP_DEPTH;
+      continue;
+    }
+    currentStepId = parentStepId;
+  }
+  ancestry.reverse();
+  for (const ancestorStepId of ancestry) {
+    resolvedDepth = Math.min(MAX_RUN_SUMMARY_DEPTH, resolvedDepth + 1);
+    depthCache.set(ancestorStepId, resolvedDepth);
+  }
+  return depthCache.get(stepId) ?? ROOT_STEP_DEPTH;
+}
 function buildRunSummary(events) {
   const started = events.find(
     (e) => e.event === "run_started"
@@ -2094,27 +2153,13 @@ function buildRunSummary(events) {
   let stepsWithKnownTotal = 0;
   let hasCachedTokens = false;
   const depthCache = /* @__PURE__ */ new Map();
-  const computeDepth = (stepId) => {
-    const cached2 = depthCache.get(stepId);
-    if (cached2 !== void 0) return cached2;
-    const node = steps.get(stepId);
-    if (!node) return 0;
-    const parent = node.parentId;
-    if (typeof parent !== "string" || parent.trim() === "" || !steps.has(parent)) {
-      depthCache.set(stepId, 0);
-      return 0;
-    }
-    const d = Math.min(1e3, computeDepth(parent) + 1);
-    depthCache.set(stepId, d);
-    return d;
-  };
   for (const [id, s] of steps.entries()) {
     totalSteps += 1;
     if (s.type === "llm") llmSteps += 1;
     else if (s.type === "tool") toolSteps2 += 1;
     else logicSteps += 1;
     if (s.status === "error") errorSteps += 1;
-    const depth = computeDepth(id);
+    const depth = computeStepDepth(id, steps, depthCache);
     if (depth > maxDepth) maxDepth = depth;
     if (typeof s.durationMs === "number" && Number.isFinite(s.durationMs)) {
       if (!longestStep || s.durationMs > longestStep.durationMs) {
@@ -2161,9 +2206,12 @@ function buildRunSummary(events) {
   };
   return summary;
 }
+var ROOT_STEP_DEPTH, MAX_RUN_SUMMARY_DEPTH;
 var init_trace_metadata = __esm({
   "packages/core/src/trace-metadata.ts"() {
     init_read_trace();
+    ROOT_STEP_DEPTH = 0;
+    MAX_RUN_SUMMARY_DEPTH = 1e3;
   }
 });
 
@@ -6820,6 +6868,330 @@ var init_logical_events = __esm({
   }
 });
 
+// packages/core/src/checks/derived-failure.ts
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pickString2(record, keys) {
+  if (!record) return void 0;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim() !== "") return value;
+  }
+  return void 0;
+}
+function pickNumber(record, keys) {
+  if (!record) return void 0;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function eventMetadata(event) {
+  const attrs = isRecord8(event.attributes) ? event.attributes : void 0;
+  const nested = attrs !== void 0 && isRecord8(attrs.metadata) ? attrs.metadata : void 0;
+  return {
+    ...attrs ?? {},
+    ...nested ?? {}
+  };
+}
+function canonicalName(event) {
+  if (event.kind === "TOOL") return resolveCanonicalToolName(event);
+  return event.name;
+}
+function linkKeys(event) {
+  const meta2 = eventMetadata(event);
+  const keys = [];
+  for (const key of ["linkedStepId", "toolCallId", "mcpToolCallId"]) {
+    const value = pickString2(meta2, [key]);
+    if (value !== void 0) keys.push(`${key}:${value}`);
+  }
+  const stepId = pickString2(meta2, ["stepId"]);
+  if (stepId !== void 0) keys.push(`stepId:${stepId}`);
+  return keys;
+}
+function buildRunContexts(logicalEvents) {
+  const byRun = /* @__PURE__ */ new Map();
+  for (const event of logicalEvents) {
+    const existing = byRun.get(event.runId) ?? {
+      runId: event.runId,
+      name: event.name
+    };
+    const meta2 = eventMetadata(event);
+    if (event.kind === "RUN" || existing.name === event.runId) {
+      existing.name = event.name || existing.name;
+    }
+    if (event.kind === "RUN" && event.status !== void 0 && event.status !== "running") {
+      existing.status = event.status;
+    }
+    existing.retryOf ??= pickString2(meta2, ["retryOf"]);
+    existing.attempt ??= pickNumber(meta2, ["attempt", "retryAttempt", "retryCount"]);
+    existing.sessionId ??= pickString2(meta2, ["sessionId", "conversationId"]);
+    existing.groupId ??= pickString2(meta2, ["groupId"]);
+    existing.parentGroupId ??= pickString2(meta2, ["parentGroupId"]);
+    existing.fallbackOf ??= pickString2(meta2, ["fallbackOf", "fallbackFrom"]);
+    byRun.set(event.runId, existing);
+  }
+  return byRun;
+}
+function sameCorrelationScope(a, b) {
+  if (a.sessionId && b.sessionId && a.sessionId === b.sessionId) return true;
+  if (a.groupId && b.groupId && a.groupId === b.groupId) return true;
+  if (a.parentGroupId && b.parentGroupId && a.parentGroupId === b.parentGroupId) {
+    return true;
+  }
+  return false;
+}
+function isSuccessful(event) {
+  return event.status === "ok";
+}
+function isFailure(event) {
+  return event.status === "error";
+}
+function compareEventOrder(a, b) {
+  const byTime = a.timestamp.localeCompare(b.timestamp);
+  if (byTime !== 0) return byTime;
+  return a.eventId.localeCompare(b.eventId);
+}
+function collectCandidates(failure, logicalEvents, runs) {
+  const failureRun = runs.get(failure.runId);
+  const failureLinks = new Set(linkKeys(failure));
+  const failureName = canonicalName(failure);
+  const failureAttempt = pickNumber(eventMetadata(failure), ["attempt", "retryAttempt", "retryCount"]) ?? failureRun?.attempt;
+  const candidates = [];
+  for (const event of logicalEvents) {
+    if (event.eventId === failure.eventId) continue;
+    if (event.status === "running") continue;
+    const eventRun = runs.get(event.runId);
+    const eventMeta = eventMetadata(event);
+    const sameRun = event.runId === failure.runId;
+    if (eventRun?.retryOf === failure.runId) {
+      candidates.push({
+        event,
+        basis: "retryOf",
+        confidence: "explicit",
+        viaRunId: event.runId
+      });
+      continue;
+    }
+    if (eventRun?.fallbackOf === failure.runId || pickString2(eventMeta, ["fallbackOf", "fallbackFrom"]) === failure.runId) {
+      candidates.push({
+        event,
+        basis: "fallbackOf",
+        confidence: "explicit",
+        viaRunId: event.runId
+      });
+      continue;
+    }
+    if (sameRun && compareEventOrder(failure, event) >= 0) continue;
+    const eventLinks = linkKeys(event);
+    const sharedLink = eventLinks.find((key) => failureLinks.has(key));
+    if (sharedLink !== void 0) {
+      candidates.push({
+        event,
+        basis: sharedLink.split(":")[0] ?? "linkedId",
+        confidence: "explicit"
+      });
+      continue;
+    }
+    const eventAttempt = pickNumber(eventMeta, ["attempt", "retryAttempt", "retryCount"]) ?? eventRun?.attempt;
+    const sameParent = failure.parentId !== void 0 && event.parentId !== void 0 && failure.parentId === event.parentId;
+    const differentParent = failure.parentId !== void 0 && event.parentId !== void 0 && failure.parentId !== event.parentId;
+    const sessionScoped = failureRun !== void 0 && eventRun !== void 0 && sameCorrelationScope(failureRun, eventRun);
+    if (canonicalName(event) === failureName && failureAttempt !== void 0 && eventAttempt !== void 0 && eventAttempt > failureAttempt && !differentParent && (sameParent || sessionScoped || sameRun)) {
+      candidates.push({
+        event,
+        basis: "attempt-progression",
+        confidence: "correlated",
+        ...event.runId !== failure.runId ? { viaRunId: event.runId } : {}
+      });
+    }
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const prev = byId.get(candidate.event.eventId);
+    if (!prev || prev.confidence !== "explicit" && candidate.confidence === "explicit") {
+      byId.set(candidate.event.eventId, candidate);
+    }
+  }
+  return [...byId.values()].sort((a, b) => compareEventOrder(a.event, b.event));
+}
+function classifyFailure(failure, candidates, runs, logicalEvents) {
+  const successful = candidates.filter((c) => isSuccessful(c.event));
+  const unsuccessful = candidates.filter((c) => !isSuccessful(c.event));
+  const retryRunIds = Object.freeze(
+    [...new Set(candidates.map((c) => c.viaRunId).filter((id) => id !== void 0))].sort(
+      (a, b) => a.localeCompare(b)
+    )
+  );
+  if (successful.length > 1) {
+    const distinctRuns = new Set(successful.map((c) => c.event.runId));
+    const distinctParents = new Set(
+      successful.map((c) => c.event.parentId ?? "").filter((id) => id !== "")
+    );
+    if (distinctRuns.size > 1 || distinctParents.size > 1) {
+      return {
+        eventId: failure.eventId,
+        runId: failure.runId,
+        name: failure.name,
+        kind: failure.kind,
+        role: "unknown",
+        confidence: "unknown",
+        basis: Object.freeze(["ambiguous-recovery-candidates"]),
+        recoveryEventIds: Object.freeze(
+          successful.map((c) => c.event.eventId).sort((a, b) => a.localeCompare(b))
+        ),
+        retryRunIds
+      };
+    }
+  }
+  if (successful.length >= 1) {
+    const best = successful[0];
+    return {
+      eventId: failure.eventId,
+      runId: failure.runId,
+      name: failure.name,
+      kind: failure.kind,
+      role: "recovered",
+      confidence: best.confidence,
+      basis: Object.freeze([best.basis]),
+      recoveryEventIds: Object.freeze(
+        successful.map((c) => c.event.eventId).sort((a, b) => a.localeCompare(b))
+      ),
+      retryRunIds
+    };
+  }
+  if (candidates.length > 0) {
+    const best = candidates[0];
+    return {
+      eventId: failure.eventId,
+      runId: failure.runId,
+      name: failure.name,
+      kind: failure.kind,
+      role: "transient",
+      confidence: best.confidence,
+      basis: Object.freeze([
+        best.basis,
+        unsuccessful.some((c) => c.event.status === void 0) ? "retry-incomplete" : "retry-without-success"
+      ]),
+      recoveryEventIds: Object.freeze([]),
+      retryRunIds
+    };
+  }
+  const failureMeta = eventMetadata(failure);
+  const declaredSuccessor = pickString2(failureMeta, [
+    "retriedBy",
+    "nextRetryRunId",
+    "retryRunId"
+  ]);
+  if (declaredSuccessor !== void 0 && !runs.has(declaredSuccessor)) {
+    return {
+      eventId: failure.eventId,
+      runId: failure.runId,
+      name: failure.name,
+      kind: failure.kind,
+      role: "transient",
+      confidence: "explicit",
+      basis: Object.freeze(["retry-declared", "retry-run-missing"]),
+      recoveryEventIds: Object.freeze([]),
+      retryRunIds: Object.freeze([declaredSuccessor])
+    };
+  }
+  for (const run of runs.values()) {
+    if (run.retryOf === failure.runId) {
+      return {
+        eventId: failure.eventId,
+        runId: failure.runId,
+        name: failure.name,
+        kind: failure.kind,
+        role: "transient",
+        confidence: "explicit",
+        basis: Object.freeze(["retryOf", "retry-run-missing-or-empty"]),
+        recoveryEventIds: Object.freeze([]),
+        retryRunIds: Object.freeze([run.runId])
+      };
+    }
+  }
+  const failureRun = runs.get(failure.runId);
+  const hasSuccessorDeclared = [...runs.values()].some((run) => run.retryOf === failure.runId);
+  const isFinalInChain = failureRun !== void 0 && !hasSuccessorDeclared && (failureRun.retryOf !== void 0 || failureRun.attempt !== void 0 && failureRun.attempt > 1 || pickNumber(eventMetadata(failure), ["attempt"]) !== void 0);
+  if (isFinalInChain && failureRun?.status === "error" && !logicalEvents.some(
+    (event) => event.runId === failure.runId && event.eventId !== failure.eventId && isSuccessful(event) && canonicalName(event) === canonicalName(failure)
+  )) {
+    return {
+      eventId: failure.eventId,
+      runId: failure.runId,
+      name: failure.name,
+      kind: failure.kind,
+      role: "terminal",
+      confidence: failureRun.retryOf !== void 0 ? "explicit" : "correlated",
+      basis: Object.freeze(["final-retry-chain-member", "enclosing-run-error"]),
+      recoveryEventIds: Object.freeze([]),
+      retryRunIds: Object.freeze(
+        failureRun.retryOf !== void 0 ? [failureRun.retryOf] : []
+      )
+    };
+  }
+  return {
+    eventId: failure.eventId,
+    runId: failure.runId,
+    name: failure.name,
+    kind: failure.kind,
+    role: "unknown",
+    confidence: "unknown",
+    basis: Object.freeze(["no-explicit-or-correlated-recovery"]),
+    recoveryEventIds: Object.freeze([]),
+    retryRunIds: Object.freeze([])
+  };
+}
+function deriveFailureFacts(logicalEvents) {
+  const runs = buildRunContexts(logicalEvents);
+  const failures = logicalEvents.filter((event) => isFailure(event)).sort(compareEventOrder);
+  const failureFacts = failures.map(
+    (failure) => classifyFailure(failure, collectCandidates(failure, logicalEvents, runs), runs, logicalEvents)
+  );
+  const byRole = /* @__PURE__ */ new Map([
+    ["transient", []],
+    ["recovered", []],
+    ["terminal", []],
+    ["unknown", []]
+  ]);
+  for (const fact2 of failureFacts) {
+    byRole.get(fact2.role).push(fact2);
+  }
+  for (const [role, list2] of byRole) {
+    byRole.set(
+      role,
+      Object.freeze(
+        [...list2].sort((a, b) => {
+          const byRun = a.runId.localeCompare(b.runId);
+          if (byRun !== 0) return byRun;
+          return a.eventId.localeCompare(b.eventId);
+        })
+      )
+    );
+  }
+  const failureRoleCounts = {
+    transient: byRole.get("transient").length,
+    recovered: byRole.get("recovered").length,
+    terminal: byRole.get("terminal").length,
+    unknown: byRole.get("unknown").length
+  };
+  return {
+    failureFacts: Object.freeze(failureFacts),
+    failuresByRole: byRole,
+    failureRoleCounts
+  };
+}
+var init_derived_failure = __esm({
+  "packages/core/src/checks/derived-failure.ts"() {
+    init_logical_events();
+  }
+});
+
 // packages/core/src/checks/trace-facts.ts
 function summarizeSemanticParity(events) {
   const projection = projectLogicalEvents(events);
@@ -6830,6 +7202,7 @@ function summarizeSemanticParity(events) {
   const finishedToolNames = Object.freeze(
     finishedTools.map((event) => resolveCanonicalToolName(event)).sort((a, b) => a.localeCompare(b))
   );
+  const derived = deriveFailureFacts(logical);
   return {
     rawEventCount: events.length,
     logicalEventCount: logical.length,
@@ -6840,13 +7213,16 @@ function summarizeSemanticParity(events) {
     parentRemapCount: projection.diagnostics.filter(
       (item) => item.code === "AI_LOGICAL_PARENT_REMAPPED"
     ).length,
-    diagnostics: projection.diagnostics
+    diagnostics: projection.diagnostics,
+    failureRoleCounts: derived.failureRoleCounts
   };
 }
 var init_trace_facts = __esm({
   "packages/core/src/checks/trace-facts.ts"() {
     init_programmatic();
+    init_derived_failure();
     init_logical_events();
+    init_derived_failure();
     formatProgrammaticDiagnostic(
       "AI_TRACE_FACTS_INPUT_NOT_NORMALIZED"
     );
@@ -7174,7 +7550,7 @@ function finishedEvents(context, kind) {
 function toolInvocationEvents(context) {
   return semanticEvents(context).filter((event) => event.kind === "TOOL");
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function eventMap(events) {
@@ -7225,7 +7601,7 @@ function pushValueEntries(entries, event, value, path44, key, depth = 0) {
     }
     return;
   }
-  if (!isRecord8(value)) return;
+  if (!isRecord9(value)) return;
   for (const nestedKey of Object.keys(value).sort((a, b) => a.localeCompare(b))) {
     pushValueEntries(
       entries,
@@ -8051,7 +8427,7 @@ function createSafetyOversizedAttributeRule(options) {
               )
             );
           }
-          if (isRecord8(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
+          if (isRecord9(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
             findings.push(
               failFinding(
                 "safety.oversizedAttribute",
@@ -8437,14 +8813,14 @@ var init_checks2 = __esm({
 });
 
 // packages/core/src/persisted/token-usage.ts
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonNegativeFinite(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
 }
 function normalizeTokenUsage(value) {
-  if (!isRecord9(value)) return void 0;
+  if (!isRecord10(value)) return void 0;
   const input3 = nonNegativeFinite(value.input);
   const output2 = nonNegativeFinite(value.output);
   const suppliedTotal = nonNegativeFinite(value.total);
@@ -9274,7 +9650,7 @@ function persistedEventsForParsedTrace(parsed) {
     sourceName: "agent-inspect-jsonl-reader"
   });
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNonEmptyString4(value) {
@@ -9289,13 +9665,13 @@ function readStringField(record, keys) {
 }
 function readRecordField(record, key) {
   const value = record[key];
-  return isRecord10(value) ? value : void 0;
+  return isRecord11(value) ? value : void 0;
 }
 function parseJsonDocument(content) {
   return JSON.parse(content);
 }
 function looksLikeOpenInferenceSpan(value) {
-  if (!isRecord10(value)) return false;
+  if (!isRecord11(value)) return false;
   const attributes = readRecordField(value, "attributes");
   return readStringField(value, ["trace_id", "traceId"]) !== void 0 && readStringField(value, ["span_id", "spanId"]) !== void 0 && (readStringField(value, ["name"]) !== void 0 || attributes?.["openinference.span.kind"] !== void 0);
 }
@@ -9320,7 +9696,7 @@ function extractOpenInferenceDocument(root) {
       unsupportedFields
     };
   }
-  if (!isRecord10(root)) return void 0;
+  if (!isRecord11(root)) return void 0;
   const rootFormat = root.format;
   const rootCompatibility = root.compatibility;
   const version2 = typeof root.version === "string" && root.version.trim() !== "" ? root.version : void 0;
@@ -9460,7 +9836,7 @@ function summarizeAttributeValue(value) {
   if (Array.isArray(value)) {
     return { type: "array", length: value.length };
   }
-  if (isRecord10(value)) {
+  if (isRecord11(value)) {
     return { type: "object", keyCount: Object.keys(value).length };
   }
   if (value === null) {
@@ -9547,7 +9923,7 @@ function mapOpenInferenceKind(span, attributes, pathPrefix) {
   }
 }
 function mapOpenInferenceStatus(status) {
-  if (!isRecord10(status)) return void 0;
+  if (!isRecord11(status)) return void 0;
   const rawCode = status.code;
   if (typeof rawCode !== "string") return void 0;
   switch (rawCode.toUpperCase()) {
@@ -9647,7 +10023,7 @@ function mapOpenInferenceSpan(span, index, version2) {
   warnings.push(...kindWarnings);
   const status = mapOpenInferenceStatus(span.status);
   const tokenUsage = readOpenInferenceTokenUsage(rawAttributes);
-  const errorMessage = isRecord10(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
+  const errorMessage = isRecord11(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
   const event = {
     schemaVersion: "0.2",
     eventId: typeof rawAttributes["agent_inspect.event_id"] === "string" ? rawAttributes["agent_inspect.event_id"] : spanId,
@@ -9715,7 +10091,7 @@ function mapOpenInferenceEvents(document) {
   };
 }
 function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
-  if (!isRecord10(value)) {
+  if (!isRecord11(value)) {
     unsupportedFields.push(field);
     warnings.push({
       code: "otlp_attribute_value_invalid",
@@ -9737,15 +10113,15 @@ function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
   if (typeof value.doubleValue === "number" && Number.isFinite(value.doubleValue)) {
     return value.doubleValue;
   }
-  if (isRecord10(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
+  if (isRecord11(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
     return value.arrayValue.values.map(
       (item, index) => parseOtlpAnyValue(item, `${field}.arrayValue.values[${index}]`, warnings, unsupportedFields)
     );
   }
-  if (isRecord10(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
+  if (isRecord11(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
     const out = {};
     for (const [index, item] of value.kvlistValue.values.entries()) {
-      if (!isRecord10(item) || typeof item.key !== "string") {
+      if (!isRecord11(item) || typeof item.key !== "string") {
         unsupportedFields.push(`${field}.kvlistValue.values[${index}]`);
         continue;
       }
@@ -9796,7 +10172,7 @@ function parseOtlpAttributes(value, pathPrefix) {
   }
   for (const [index, item] of value.entries()) {
     const field = `${pathPrefix}[${index}]`;
-    if (!isRecord10(item) || typeof item.key !== "string") {
+    if (!isRecord11(item) || typeof item.key !== "string") {
       unsupportedFields.push(field);
       warnings.push({
         code: "otlp_attribute_invalid",
@@ -9819,16 +10195,16 @@ function parseOtlpAttributes(value, pathPrefix) {
   return { attributes, warnings, unsupportedFields };
 }
 function looksLikeOtlpSpan(value) {
-  return isRecord10(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
+  return isRecord11(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
 }
 function extractOtlpDocument(root) {
-  if (!isRecord10(root) || !Array.isArray(root.resourceSpans)) return void 0;
+  if (!isRecord11(root) || !Array.isArray(root.resourceSpans)) return void 0;
   const spans = [];
   const warnings = [];
   const unsupportedFields = [];
   for (const [resourceIndex, resourceSpan] of root.resourceSpans.entries()) {
     const resourcePath = `resourceSpans[${resourceIndex}]`;
-    if (!isRecord10(resourceSpan)) {
+    if (!isRecord11(resourceSpan)) {
       unsupportedFields.push(resourcePath);
       continue;
     }
@@ -9851,7 +10227,7 @@ function extractOtlpDocument(root) {
     }
     for (const [scopeIndex, scopeSpan] of resourceSpan.scopeSpans.entries()) {
       const scopePath = `${resourcePath}.scopeSpans[${scopeIndex}]`;
-      if (!isRecord10(scopeSpan)) {
+      if (!isRecord11(scopeSpan)) {
         unsupportedFields.push(scopePath);
         continue;
       }
@@ -9918,7 +10294,7 @@ function extractOtlpDocument(root) {
   };
 }
 function mapOtlpStatus(status) {
-  if (!isRecord10(status)) return void 0;
+  if (!isRecord11(status)) return void 0;
   const rawCode = status.code;
   if (typeof rawCode !== "string") return void 0;
   switch (rawCode.toUpperCase()) {
@@ -10018,7 +10394,7 @@ function mapOtlpEvents(value, pathPrefix) {
   const events = [];
   for (const [index, event] of value.entries()) {
     const eventPath = `${pathPrefix}[${index}]`;
-    if (!isRecord10(event)) {
+    if (!isRecord11(event)) {
       unsupportedFields.push(eventPath);
       continue;
     }
@@ -10156,7 +10532,7 @@ function mapOtlpSpan(context) {
   warnings.push(...kindWarnings);
   const status = mapOtlpStatus(span.status);
   const tokenUsage = readOtlpTokenUsage(parsedSpanAttributes.attributes);
-  const errorMessage = isRecord10(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
+  const errorMessage = isRecord11(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
   const event = {
     schemaVersion: "0.2",
     eventId: typeof parsedSpanAttributes.attributes["agent_inspect.event_id"] === "string" ? parsedSpanAttributes.attributes["agent_inspect.event_id"] : spanId,
@@ -12595,7 +12971,7 @@ var init_src = __esm({
 });
 
 // package.json
-var version = "6.18.0";
+var version = "6.19.1";
 
 // packages/cli/src/list.ts
 init_advanced();
@@ -13257,7 +13633,7 @@ async function view(runId, options = {}) {
     process.exitCode = 1;
   }
 }
-function isRecord11(v) {
+function isRecord12(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function isNonEmptyStringArray(v) {
@@ -13269,7 +13645,7 @@ function validateRedact(redact2) {
   }
   for (const r of redact2) {
     if (typeof r === "string") continue;
-    if (!isRecord11(r)) {
+    if (!isRecord12(r)) {
       throw new Error("Invalid config: redact entries must be strings or objects");
     }
     if (typeof r.key !== "string" || r.key.trim() === "") {
@@ -13288,7 +13664,7 @@ function validateRedact(redact2) {
   }
 }
 function validateMappings(mappings) {
-  if (!isRecord11(mappings)) {
+  if (!isRecord12(mappings)) {
     throw new Error("Invalid config: mappings must be an object");
   }
 }
@@ -13338,7 +13714,7 @@ async function loadLogIngestConfig(configPath) {
     const msg = e instanceof Error ? e.message : String(e);
     throw new Error(`Invalid JSON in config file: ${configPath} (${msg})`);
   }
-  if (!isRecord11(parsed)) {
+  if (!isRecord12(parsed)) {
     throw new Error("Invalid config: expected a JSON object at top-level");
   }
   const user = parsed;
@@ -13375,7 +13751,7 @@ async function loadLogIngestConfig(configPath) {
   }
   return mergeLogIngestConfig(DEFAULT_LOG_INGEST_CONFIG, user);
 }
-function isRecord12(v) {
+function isRecord13(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var JsonLogParser = class {
@@ -13400,7 +13776,7 @@ var JsonLogParser = class {
         });
         continue;
       }
-      if (!isRecord12(parsed)) {
+      if (!isRecord13(parsed)) {
         warnings.push({
           code: "MALFORMED_JSON",
           message: "JSON log line must be an object",
@@ -13431,7 +13807,7 @@ var JsonLogParser = class {
     return this.parseLines(lines, filePath);
   }
 };
-function isRecord13(v) {
+function isRecord14(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function findLastJsonObjectSubstring(line) {
@@ -13507,7 +13883,7 @@ var Log4jsParser = class {
         });
         continue;
       }
-      if (!isRecord13(parsed)) {
+      if (!isRecord14(parsed)) {
         warnings.push({
           code: "UNSUPPORTED_LOG4JS_PAYLOAD",
           message: "Embedded JSON payload must be an object",
@@ -14386,7 +14762,7 @@ var EXPORT_PAYLOAD_VERSION = "0.1.2";
 // packages/core/src/exporters/redact-export.ts
 init_redactor();
 init_redaction_profiles();
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function deepClone(value) {
@@ -14460,7 +14836,7 @@ function redactEventAttributes(attrs, redactor, maxMetadataValueLength, maxPrevi
     0
   );
   const err = bounded.error;
-  if (isRecord14(err) && typeof err.message === "string") {
+  if (isRecord15(err) && typeof err.message === "string") {
     bounded.error = {
       ...err,
       message: truncateStringForProfile(
@@ -14490,7 +14866,7 @@ function redactErrorInfo(error, redactor, maxMetadataValueLength, maxPreviewLeng
     maxPreviewLength
   );
   const redacted = record?.error;
-  if (!isRecord14(redacted) || typeof redacted.message !== "string") {
+  if (!isRecord15(redacted) || typeof redacted.message !== "string") {
     return void 0;
   }
   return {
@@ -14570,7 +14946,7 @@ function redactTraceEventsForReport(events, options) {
         ) : void 0;
         const redactedActual = actualAttrs !== void 0 && "value" in actualAttrs ? actualAttrs.value : void 0;
         const redactedEvidence = event.evidence !== void 0 ? redactEventAttributes(
-          isRecord14(event.evidence) ? event.evidence : { value: event.evidence },
+          isRecord15(event.evidence) ? event.evidence : { value: event.evidence },
           redactor,
           maxMetadataValueLength,
           maxPreviewLength
@@ -16653,7 +17029,7 @@ var STRICT_PROFILE_EXTRA_KEYS2 = [
   "retrieval",
   "query"
 ];
-function isRecord15(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function toKey2(key) {
@@ -17033,7 +17409,7 @@ var Redactor2 = class {
       });
       return out;
     }
-    if (isRecord15(value)) {
+    if (isRecord16(value)) {
       if (state.seen.has(value)) return state.seen.get(value);
       const out = {};
       state.seen.set(value, out);
@@ -17066,7 +17442,7 @@ var REDACTION_POLICY_LIMITS = {
   maxTypedQuantifier: 64
 };
 var SAFE_TYPED_PATTERN = /^[A-Za-z0-9_@./:=<>\-[\]()|+*?{},\\\s^$]+$/;
-function isRecord16(value) {
+function isRecord17(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function escapeRegExp(value) {
@@ -17136,7 +17512,7 @@ function assertBoundedTypedPattern(pattern, label) {
 }
 function compilePatternDetector(input3, index) {
   const label = `patterns[${index}]`;
-  if (!isRecord16(input3)) throw new Error(`${label} must be an object.`);
+  if (!isRecord17(input3)) throw new Error(`${label} must be an object.`);
   const idRaw = input3.id;
   if (typeof idRaw !== "string" || idRaw.trim() === "") {
     throw new Error(`${label}.id must be a non-empty string.`);
@@ -17197,7 +17573,7 @@ function compilePatternDetector(input3, index) {
   };
 }
 function compileRedactionPolicy(raw, policyPath) {
-  if (!isRecord16(raw)) {
+  if (!isRecord17(raw)) {
     throw new Error(`Redaction policy must be a JSON object (${policyPath}).`);
   }
   const diagnostics = [];
@@ -18207,7 +18583,7 @@ async function openCommand(input3, options = {}, stdin = process.stdin) {
 
 // packages/cli/src/migrate.ts
 init_advanced();
-function isRecord17(value) {
+function isRecord18(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseTarget(value) {
@@ -18216,7 +18592,7 @@ function parseTarget(value) {
   throw new Error('Unsupported migration target. Use "--to 1.0".');
 }
 function formatOf(value) {
-  if (!isRecord17(value)) return "unknown";
+  if (!isRecord18(value)) return "unknown";
   if (value.schemaVersion === "0.1") return "0.1";
   if (value.schemaVersion === "0.2") return "0.2";
   if (value.schemaVersion === "1.0") return "1.0";
@@ -22569,7 +22945,8 @@ async function artifactsCommand(target, options = {}, stdin = process.stdin) {
           finishedToolNames: [...parity.finishedToolNames],
           pairedCount: parity.pairedCount,
           parentRemapCount: parity.parentRemapCount,
-          contractStatus: check.status === "pass" ? "pass" : check.status === "fail" ? "fail" : "error"
+          contractStatus: check.status === "pass" ? "pass" : check.status === "fail" ? "fail" : "error",
+          ...parity.failureRoleCounts !== void 0 ? { failureRoleCounts: { ...parity.failureRoleCounts } } : {}
         }
       });
       await writeArtifact(outputDir, "evidence.html", evidencePackage["evidence.html"], files);
@@ -24662,8 +25039,11 @@ async function readSnapshot(indexPath2) {
   try {
     const raw = await promises.readFile(indexPath2, "utf8");
     return JSON.parse(raw);
-  } catch {
-    return void 0;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
   }
 }
 async function indexBuildCommand(options = {}) {