agent-inspect 6.12.0 → 6.12.2

package/packages/core/dist/checks.d.cts

@@ -1,5 +1,5 @@
-import { T as TraceCheckInput, a as TraceCheckResult } from './index-mdFcxSOR.cjs';
-export { B as BaselineRegressionRuleOptions, D as DecisionRuleOptions, G as GuardrailRuleOptions, L as LlmUsageRuleOptions, M as MaxStepDurationRuleOptions, O as ObservedOutcomeRuleOptions, R as RetrievalRuleOptions, b as RunDepthRuleOptions, c as RunDurationRuleOptions, d as RunEventCountRuleOptions, e as RunStatusRuleOptions, f as RunTraceChecksOptions, S as SafetyFindingCategory, g as SafetyFindingConfidence, h as SafetyOversizedAttributeRuleOptions, i as SafetyRawContentRuleOptions, j as SafetyRedactionRuleOptions, k as SafetySecretPattern, l as SafetySecretPatternRuleOptions, m as StallDetectionRuleOptions, n as StructureIncompleteRuleOptions, o as StructureOrphanRuleOptions, p as StructureParallelWidthRuleOptions, q as StructureRelationshipRuleOptions, r as ToolFailureRuleOptions, s as ToolOrderingRuleOptions, t as ToolUsageRuleOptions, u as TraceCheckContext, v as TraceCheckDiagnostic, w as TraceCheckDiagnosticCode, x as TraceCheckEvidence, y as TraceCheckFacts, z as TraceCheckFinding, A as TraceCheckFindingStatus, C as TraceCheckRule, E as TraceCheckRuleCategory, F as TraceCheckSeverity, H as TraceCheckStatus, I as TraceCheckSummary, J as TraceSignalRuleOptions, K as createBaselineRegressionRule, N as createDecisionRule, P as createGuardrailRule, Q as createLlmUsageRule, U as createMaxStepDurationRule, V as createObservedOutcomeRule, W as createRequireCompletedRule, X as createRetrievalRule, Y as createRunDepthRule, Z as createRunDurationRule, _ as createRunEventCountRule, $ as createRunStatusRule, a0 as createSafetyOversizedAttributeRule, a1 as createSafetyRawContentRule, a2 as createSafetyRedactionRule, a3 as createSafetySecretPatternRule, a4 as createStallDetectionRule, a5 as createStructureCycleRule, a6 as createStructureIncompleteRule, a7 as createStructureOrphanRule, a8 as createStructureParallelWidthRule, a9 as createStructureRelationshipRule, aa as createToolFailureRule, ab as createToolOrderingRule, ac as createToolUsageRule, ad as runTraceChecks } from './index-mdFcxSOR.cjs';
+import { T as TraceCheckInput, a as TraceCheckResult } from './index-BOP33T4O.cjs';
+export { B as BaselineRegressionRuleOptions, D as DecisionRuleOptions, G as GuardrailRuleOptions, L as LlmUsageRuleOptions, b as LogicalProjectionDiagnostic, c as LogicalTraceEvent, M as MaxStepDurationRuleOptions, O as ObservedOutcomeRuleOptions, R as RetrievalRuleOptions, d as RunDepthRuleOptions, e as RunDurationRuleOptions, f as RunEventCountRuleOptions, g as RunStatusRuleOptions, h as RunTraceChecksOptions, S as SafetyFindingCategory, i as SafetyFindingConfidence, j as SafetyOversizedAttributeRuleOptions, k as SafetyRawContentRuleOptions, l as SafetyRedactionRuleOptions, m as SafetySecretPattern, n as SafetySecretPatternRuleOptions, o as StallDetectionRuleOptions, p as StructureIncompleteRuleOptions, q as StructureOrphanRuleOptions, r as StructureParallelWidthRuleOptions, s as StructureRelationshipRuleOptions, t as ToolFailureRuleOptions, u as ToolOrderingRuleOptions, v as ToolUsageRuleOptions, w as TraceCheckContext, x as TraceCheckDiagnostic, y as TraceCheckDiagnosticCode, z as TraceCheckEvidence, A as TraceCheckFacts, C as TraceCheckFinding, E as TraceCheckFindingStatus, F as TraceCheckRule, H as TraceCheckRuleCategory, I as TraceCheckSeverity, J as TraceCheckStatus, K as TraceCheckSummary, N as TraceSignalRuleOptions, P as createBaselineRegressionRule, Q as createDecisionRule, U as createGuardrailRule, V as createLlmUsageRule, W as createMaxStepDurationRule, X as createObservedOutcomeRule, Y as createRequireCompletedRule, Z as createRetrievalRule, _ as createRunDepthRule, $ as createRunDurationRule, a0 as createRunEventCountRule, a1 as createRunStatusRule, a2 as createSafetyOversizedAttributeRule, a3 as createSafetyRawContentRule, a4 as createSafetyRedactionRule, a5 as createSafetySecretPatternRule, a6 as createStallDetectionRule, a7 as createStructureCycleRule, a8 as createStructureIncompleteRule, a9 as createStructureOrphanRule, aa as createStructureParallelWidthRule, ab as createStructureRelationshipRule, ac as createToolFailureRule, ad as createToolOrderingRule, ae as createToolUsageRule, af as projectLogicalEvents, ag as resolveCanonicalToolName, ah as runTraceChecks } from './index-BOP33T4O.cjs';
 import './readers.cjs';
 import './inspect-event-DVg84S4v.cjs';
 import './persisted-inspect-event-d-mSP8kd.cjs';

package/packages/core/dist/checks.d.ts

@@ -1,5 +1,5 @@
-import { T as TraceCheckInput, a as TraceCheckResult } from './index-BO7l0iAe.js';
-export { B as BaselineRegressionRuleOptions, D as DecisionRuleOptions, G as GuardrailRuleOptions, L as LlmUsageRuleOptions, M as MaxStepDurationRuleOptions, O as ObservedOutcomeRuleOptions, R as RetrievalRuleOptions, b as RunDepthRuleOptions, c as RunDurationRuleOptions, d as RunEventCountRuleOptions, e as RunStatusRuleOptions, f as RunTraceChecksOptions, S as SafetyFindingCategory, g as SafetyFindingConfidence, h as SafetyOversizedAttributeRuleOptions, i as SafetyRawContentRuleOptions, j as SafetyRedactionRuleOptions, k as SafetySecretPattern, l as SafetySecretPatternRuleOptions, m as StallDetectionRuleOptions, n as StructureIncompleteRuleOptions, o as StructureOrphanRuleOptions, p as StructureParallelWidthRuleOptions, q as StructureRelationshipRuleOptions, r as ToolFailureRuleOptions, s as ToolOrderingRuleOptions, t as ToolUsageRuleOptions, u as TraceCheckContext, v as TraceCheckDiagnostic, w as TraceCheckDiagnosticCode, x as TraceCheckEvidence, y as TraceCheckFacts, z as TraceCheckFinding, A as TraceCheckFindingStatus, C as TraceCheckRule, E as TraceCheckRuleCategory, F as TraceCheckSeverity, H as TraceCheckStatus, I as TraceCheckSummary, J as TraceSignalRuleOptions, K as createBaselineRegressionRule, N as createDecisionRule, P as createGuardrailRule, Q as createLlmUsageRule, U as createMaxStepDurationRule, V as createObservedOutcomeRule, W as createRequireCompletedRule, X as createRetrievalRule, Y as createRunDepthRule, Z as createRunDurationRule, _ as createRunEventCountRule, $ as createRunStatusRule, a0 as createSafetyOversizedAttributeRule, a1 as createSafetyRawContentRule, a2 as createSafetyRedactionRule, a3 as createSafetySecretPatternRule, a4 as createStallDetectionRule, a5 as createStructureCycleRule, a6 as createStructureIncompleteRule, a7 as createStructureOrphanRule, a8 as createStructureParallelWidthRule, a9 as createStructureRelationshipRule, aa as createToolFailureRule, ab as createToolOrderingRule, ac as createToolUsageRule, ad as runTraceChecks } from './index-BO7l0iAe.js';
+import { T as TraceCheckInput, a as TraceCheckResult } from './index-CgCH8NE9.js';
+export { B as BaselineRegressionRuleOptions, D as DecisionRuleOptions, G as GuardrailRuleOptions, L as LlmUsageRuleOptions, b as LogicalProjectionDiagnostic, c as LogicalTraceEvent, M as MaxStepDurationRuleOptions, O as ObservedOutcomeRuleOptions, R as RetrievalRuleOptions, d as RunDepthRuleOptions, e as RunDurationRuleOptions, f as RunEventCountRuleOptions, g as RunStatusRuleOptions, h as RunTraceChecksOptions, S as SafetyFindingCategory, i as SafetyFindingConfidence, j as SafetyOversizedAttributeRuleOptions, k as SafetyRawContentRuleOptions, l as SafetyRedactionRuleOptions, m as SafetySecretPattern, n as SafetySecretPatternRuleOptions, o as StallDetectionRuleOptions, p as StructureIncompleteRuleOptions, q as StructureOrphanRuleOptions, r as StructureParallelWidthRuleOptions, s as StructureRelationshipRuleOptions, t as ToolFailureRuleOptions, u as ToolOrderingRuleOptions, v as ToolUsageRuleOptions, w as TraceCheckContext, x as TraceCheckDiagnostic, y as TraceCheckDiagnosticCode, z as TraceCheckEvidence, A as TraceCheckFacts, C as TraceCheckFinding, E as TraceCheckFindingStatus, F as TraceCheckRule, H as TraceCheckRuleCategory, I as TraceCheckSeverity, J as TraceCheckStatus, K as TraceCheckSummary, N as TraceSignalRuleOptions, P as createBaselineRegressionRule, Q as createDecisionRule, U as createGuardrailRule, V as createLlmUsageRule, W as createMaxStepDurationRule, X as createObservedOutcomeRule, Y as createRequireCompletedRule, Z as createRetrievalRule, _ as createRunDepthRule, $ as createRunDurationRule, a0 as createRunEventCountRule, a1 as createRunStatusRule, a2 as createSafetyOversizedAttributeRule, a3 as createSafetyRawContentRule, a4 as createSafetyRedactionRule, a5 as createSafetySecretPatternRule, a6 as createStallDetectionRule, a7 as createStructureCycleRule, a8 as createStructureIncompleteRule, a9 as createStructureOrphanRule, aa as createStructureParallelWidthRule, ab as createStructureRelationshipRule, ac as createToolFailureRule, ad as createToolOrderingRule, ae as createToolUsageRule, af as projectLogicalEvents, ag as resolveCanonicalToolName, ah as runTraceChecks } from './index-CgCH8NE9.js';
 import './readers.js';
 import './inspect-event-DVg84S4v.js';
 import './persisted-inspect-event-ChE7pGb7.js';

package/packages/core/dist/checks.mjs

@@ -1,4 +1,4 @@
-export { createBaselineRegressionRule, createDecisionRule, createGuardrailRule, createLlmUsageRule, createMaxStepDurationRule, createObservedOutcomeRule, createRequireCompletedRule, createRetrievalRule, createRunDepthRule, createRunDurationRule, createRunEventCountRule, createRunStatusRule, createSafetyOversizedAttributeRule, createSafetyRawContentRule, createSafetyRedactionRule, createSafetySecretPatternRule, createStallDetectionRule, createStructureCycleRule, createStructureIncompleteRule, createStructureOrphanRule, createStructureParallelWidthRule, createStructureRelationshipRule, createToolFailureRule, createToolOrderingRule, createToolUsageRule, defineTraceContract, evaluateTraceContract, runTraceChecks } from './chunk-QT6CQ2XA.mjs';
+export { createBaselineRegressionRule, createDecisionRule, createGuardrailRule, createLlmUsageRule, createMaxStepDurationRule, createObservedOutcomeRule, createRequireCompletedRule, createRetrievalRule, createRunDepthRule, createRunDurationRule, createRunEventCountRule, createRunStatusRule, createSafetyOversizedAttributeRule, createSafetyRawContentRule, createSafetyRedactionRule, createSafetySecretPatternRule, createStallDetectionRule, createStructureCycleRule, createStructureIncompleteRule, createStructureOrphanRule, createStructureParallelWidthRule, createStructureRelationshipRule, createToolFailureRule, createToolOrderingRule, createToolUsageRule, defineTraceContract, evaluateTraceContract, projectLogicalEvents, resolveCanonicalToolName, runTraceChecks } from './chunk-KJICERSD.mjs';
 import './chunk-VFO76UH3.mjs';
 import './chunk-ULCGIRTC.mjs';
 import './chunk-VU6O5QAH.mjs';

package/packages/core/dist/{chunk-QT6CQ2XA.mjs → chunk-KJICERSD.mjs}

@@ -1,5 +1,259 @@
 import { extractOutcomesFromPersistedEvents, outcomesMatchingStatus } from './chunk-VFO76UH3.mjs';
 
+// packages/core/src/checks/logical-events.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function legacyEvent(event) {
+  const value = event.attributes?.legacyEvent;
+  return typeof value === "string" ? value : void 0;
+}
+function stepIdOf(event) {
+  const value = event.attributes?.stepId;
+  if (typeof value === "string" && value.trim() !== "") return value;
+  return void 0;
+}
+function cloneEvent(event) {
+  return {
+    ...event,
+    ...event.attributes !== void 0 ? { attributes: { ...event.attributes } } : {},
+    ...event.error !== void 0 ? { error: { ...event.error } } : {},
+    ...event.tokenUsage !== void 0 ? { tokenUsage: { ...event.tokenUsage } } : {},
+    ...event.source !== void 0 ? { source: { ...event.source } } : {}
+  };
+}
+function mergeAttributes(start, complete) {
+  const merged = {
+    ...isRecord(complete.attributes) ? complete.attributes : {},
+    ...isRecord(start.attributes) ? start.attributes : {}
+  };
+  merged.legacyEvent = start.attributes?.legacyEvent ?? complete.attributes?.legacyEvent;
+  merged.legacyCompleteEvent = complete.attributes?.legacyEvent;
+  if (complete.attributes?.errorStack !== void 0) {
+    merged.errorStack = complete.attributes.errorStack;
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function pairStartComplete(start, complete) {
+  const attributes = mergeAttributes(start, complete);
+  const paired = {
+    ...cloneEvent(start),
+    status: complete.status,
+    timestamp: complete.timestamp ?? start.timestamp,
+    ...complete.endedAt !== void 0 ? { endedAt: complete.endedAt } : {},
+    ...complete.durationMs !== void 0 ? { durationMs: complete.durationMs } : {},
+    ...complete.error !== void 0 ? { error: { ...complete.error } } : {},
+    ...complete.tokenUsage !== void 0 && start.tokenUsage === void 0 ? { tokenUsage: { ...complete.tokenUsage } } : {},
+    ...attributes !== void 0 ? { attributes } : {}
+  };
+  return {
+    ...paired,
+    sourceEventIds: Object.freeze([start.eventId, complete.eventId]),
+    projection: {
+      paired: true,
+      absorbedEventIds: Object.freeze([complete.eventId]),
+      parentNormalized: false,
+      ...start.parentId !== void 0 ? { originalParentId: start.parentId } : {}
+    }
+  };
+}
+function asLogical(event, extras) {
+  return {
+    ...cloneEvent(event),
+    sourceEventIds: Object.freeze([event.eventId]),
+    projection: {
+      paired: false,
+      absorbedEventIds: Object.freeze([]),
+      parentNormalized: extras?.parentNormalized === true,
+      ...{}
+    }
+  };
+}
+function projectLogicalEvents(events) {
+  const diagnostics = [];
+  const byRun = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const list = byRun.get(event.runId) ?? [];
+    list.push(event);
+    byRun.set(event.runId, list);
+  }
+  const absorbedIds = /* @__PURE__ */ new Set();
+  const logicalByRawId = /* @__PURE__ */ new Map();
+  const stepIdToLogicalId = /* @__PURE__ */ new Map();
+  const logical = [];
+  const orderedRuns = [...byRun.keys()].sort((a, b) => a.localeCompare(b));
+  for (const runId of orderedRuns) {
+    const runEvents = byRun.get(runId) ?? [];
+    const starts = [];
+    const completes = [];
+    const others = [];
+    for (const event of runEvents) {
+      const legacy = legacyEvent(event);
+      if (legacy === "step_started" || legacy === "run_started" && event.status === "running") {
+        starts.push(event);
+      } else if (legacy === "step_completed" || legacy === "run_completed") {
+        completes.push(event);
+      } else {
+        others.push(event);
+      }
+    }
+    const usedCompletes = /* @__PURE__ */ new Set();
+    for (const start of starts) {
+      const stepId = stepIdOf(start);
+      let match;
+      if (legacyEvent(start) === "run_started") {
+        const candidates = completes.filter(
+          (c) => !usedCompletes.has(c.eventId) && legacyEvent(c) === "run_completed"
+        );
+        if (candidates.length > 1) {
+          diagnostics.push({
+            code: "AI_LOGICAL_PAIR_AMBIGUOUS",
+            message: `Multiple run_completed rows for run ${runId}; using first by eventId.`,
+            eventIds: candidates.map((c) => c.eventId)
+          });
+          candidates.sort((a, b) => a.eventId.localeCompare(b.eventId));
+        }
+        match = candidates[0];
+      } else if (stepId) {
+        const candidates = completes.filter(
+          (c) => !usedCompletes.has(c.eventId) && legacyEvent(c) === "step_completed" && stepIdOf(c) === stepId
+        );
+        if (candidates.length > 1) {
+          diagnostics.push({
+            code: "AI_LOGICAL_PAIR_AMBIGUOUS",
+            message: `Multiple step_completed rows for stepId ${stepId}; using first by eventId.`,
+            eventIds: candidates.map((c) => c.eventId)
+          });
+          candidates.sort((a, b) => a.eventId.localeCompare(b.eventId));
+        }
+        match = candidates[0];
+      }
+      if (match) {
+        usedCompletes.add(match.eventId);
+        absorbedIds.add(match.eventId);
+        const paired = pairStartComplete(start, match);
+        logical.push(paired);
+        logicalByRawId.set(start.eventId, paired);
+        logicalByRawId.set(match.eventId, paired);
+        if (stepId) stepIdToLogicalId.set(`${runId}:${stepId}`, paired.eventId);
+      } else {
+        diagnostics.push({
+          code: "AI_LOGICAL_PAIR_UNMATCHED_START",
+          message: `No matching complete for start ${start.eventId}.`,
+          eventIds: [start.eventId]
+        });
+        const alone = asLogical(start);
+        logical.push(alone);
+        logicalByRawId.set(start.eventId, alone);
+        if (stepId) stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      }
+    }
+    for (const complete of completes) {
+      if (usedCompletes.has(complete.eventId)) continue;
+      diagnostics.push({
+        code: "AI_LOGICAL_PAIR_UNMATCHED_COMPLETE",
+        message: `No matching start for complete ${complete.eventId}.`,
+        eventIds: [complete.eventId]
+      });
+      const alone = asLogical(complete);
+      logical.push(alone);
+      logicalByRawId.set(complete.eventId, alone);
+      const stepId = stepIdOf(complete);
+      if (stepId && !stepIdToLogicalId.has(`${runId}:${stepId}`)) {
+        stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      }
+    }
+    for (const event of others) {
+      const alone = asLogical(event);
+      logical.push(alone);
+      logicalByRawId.set(event.eventId, alone);
+      const stepId = stepIdOf(event);
+      if (stepId && !stepIdToLogicalId.has(`${runId}:${stepId}`)) {
+        stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      }
+    }
+  }
+  const logicalById = new Map(logical.map((e) => [e.eventId, e]));
+  const normalized = [];
+  for (const event of logical) {
+    const originalParentId = event.parentId;
+    if (!originalParentId) {
+      normalized.push(event);
+      continue;
+    }
+    let nextParent = originalParentId;
+    let remapped = false;
+    const viaAbsorbed = logicalByRawId.get(originalParentId);
+    if (viaAbsorbed && viaAbsorbed.eventId !== originalParentId) {
+      nextParent = viaAbsorbed.eventId;
+      remapped = true;
+    } else if (!logicalById.has(originalParentId)) {
+      const viaStep = stepIdToLogicalId.get(`${event.runId}:${originalParentId}`);
+      if (viaStep) {
+        nextParent = viaStep;
+        remapped = true;
+      }
+    }
+    if (!remapped) {
+      if (!logicalById.has(originalParentId) && !logicalByRawId.has(originalParentId)) {
+        diagnostics.push({
+          code: "AI_LOGICAL_PARENT_UNRESOLVED",
+          message: `Parent ${originalParentId} unresolved for ${event.eventId}.`,
+          eventIds: [event.eventId]
+        });
+      }
+      normalized.push(event);
+      continue;
+    }
+    diagnostics.push({
+      code: "AI_LOGICAL_PARENT_REMAPPED",
+      message: `Remapped parent ${originalParentId} \u2192 ${nextParent} for ${event.eventId}.`,
+      eventIds: [event.eventId]
+    });
+    normalized.push({
+      ...event,
+      parentId: nextParent,
+      projection: {
+        ...event.projection,
+        parentNormalized: true,
+        originalParentId
+      }
+    });
+  }
+  const rawIndex = new Map(events.map((e, i) => [e.eventId, i]));
+  normalized.sort((a, b) => {
+    const ai = rawIndex.get(a.sourceEventIds[0]) ?? 0;
+    const bi = rawIndex.get(b.sourceEventIds[0]) ?? 0;
+    return ai - bi || a.eventId.localeCompare(b.eventId);
+  });
+  return {
+    logicalEvents: Object.freeze(normalized),
+    diagnostics: Object.freeze(diagnostics)
+  };
+}
+function resolveCanonicalToolName(event) {
+  const attrs = event.attributes;
+  const direct = pickString(attrs, ["toolName", "tool"]);
+  if (direct) return direct;
+  const metadata = attrs?.metadata;
+  if (isRecord(metadata)) {
+    const nested = pickString(metadata, ["toolName", "tool"]);
+    if (nested) return nested;
+  }
+  for (const prefix of ["tool:", "function:", "mcp-tools:"]) {
+    if (event.name.startsWith(prefix)) return event.name.slice(prefix.length);
+  }
+  return event.name;
+}
+function pickString(record, keys) {
+  if (!record) return void 0;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
+  }
+  return void 0;
+}
+
 // packages/core/src/checks/index.ts
 var SEVERITY_RANK = {
   error: 0,
@@ -58,7 +312,11 @@ var DEFAULT_RAW_CONTENT_KEYS = [
   "conversationtext",
   "conversation_text"
 ];
-var DEFAULT_SAFE_RAW_CONTENT_PATH_PREFIXES = ["tokenUsage", "usage"];
+var DEFAULT_SAFE_RAW_CONTENT_PATH_PREFIXES = [
+  "tokenUsage",
+  "usage",
+  "tokens"
+];
 var SAFE_USAGE_LEAF_KEYS = /* @__PURE__ */ new Set([
   "input",
   "output",
@@ -134,10 +392,13 @@ function buildFacts(input, selectedRun) {
       childrenByParentId.set(parentId, children);
     }
   }
+  const projection = projectLogicalEvents(scopedEvents);
   return {
     format: input.read.format,
     runs: Object.freeze([...input.read.runs]),
     events: Object.freeze([...scopedEvents]),
+    logicalEvents: projection.logicalEvents,
+    logicalProjectionDiagnostics: projection.diagnostics,
     readerWarnings: Object.freeze([...input.read.warnings]),
     unsupportedFields: Object.freeze([...input.read.unsupportedFields]),
     sourceFiles: Object.freeze([...input.read.sourceFiles]),
@@ -330,7 +591,10 @@ function failFinding(ruleId, message, evidence, expected, actual, meta) {
   };
 }
 function toolName(event) {
-  return stringAttr(event, ["toolName", "tool"]) ?? stripPrefix(event.name, ["tool:", "function:", "mcp-tools:"]);
+  return resolveCanonicalToolName(event);
+}
+function semanticEvents(context) {
+  return context.logicalEvents ?? context.events;
 }
 function llmModel(event) {
   return stringAttr(event, ["model", "modelId", "responseModelId", "modelName", "model_name"]) ?? stripPrefix(event.name, ["llm:", "generation:", "transcription:", "speech:"]);
@@ -345,7 +609,7 @@ function retryCount(event) {
   return numericAttr(event, ["retryCount", "retryAttempt", "retry_attempt", "attempt"]);
 }
 function finishedEvents(context, kind) {
-  return context.events.filter(
+  return semanticEvents(context).filter(
     (event) => (kind === void 0 || event.kind === kind) && event.status !== "running"
   );
 }
@@ -357,7 +621,7 @@ function firstIndexByName(events) {
   }
   return index;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function eventMap(events) {
@@ -411,7 +675,7 @@ function pushValueEntries(entries, event, value, path, key, depth = 0) {
     }
     return;
   }
-  if (!isRecord(value)) return;
+  if (!isRecord2(value)) return;
   for (const nestedKey of Object.keys(value).sort((a, b) => a.localeCompare(b))) {
     pushValueEntries(
       entries,
@@ -491,14 +755,11 @@ function signalName(event, attributeKeys, prefixes) {
   return stringAttr(event, attributeKeys) ?? stripPrefix(event.name, prefixes);
 }
 function guardrailEvents(context) {
-  return finishedEvents2().filter((event) => {
+  return finishedEvents(context).filter((event) => {
     const name = event.name.toLowerCase();
     if (name.startsWith("guardrail:") || name.includes(".guardrail.")) return true;
     return stringAttr(event, ["guardrailName", "guardrail", "guardrailId"]) !== void 0;
   });
-  function finishedEvents2() {
-    return context.events.filter((event) => event.status !== "running");
-  }
 }
 function retryValue(event) {
   return retryCount(event) ?? 0;
@@ -519,7 +780,7 @@ function treeShape(nodes) {
   return lines;
 }
 function statusShape(context) {
-  return context.events.map((event) => `${event.kind}:${event.name}:${event.status ?? "unknown"}`).sort((a, b) => a.localeCompare(b));
+  return semanticEvents(context).map((event) => `${event.kind}:${event.name}:${event.status ?? "unknown"}`).sort((a, b) => a.localeCompare(b));
 }
 function toolShape(context) {
   return finishedEvents(context, "TOOL").map(
@@ -545,7 +806,7 @@ function llmShape(context) {
   );
 }
 function errorShape(context) {
-  return context.events.filter((event) => event.status === "error" || event.error !== void 0).map(
+  return semanticEvents(context).filter((event) => event.status === "error" || event.error !== void 0).map(
     (event) => [
       event.kind,
       event.name,
@@ -563,7 +824,7 @@ function guardrailShape(context) {
   return guardrailEvents(context).map((event) => signalName(event, ["guardrailName", "guardrail", "guardrailId"], ["guardrail:"])).sort((a, b) => a.localeCompare(b));
 }
 function firstEvidenceForKind(context, kind, path) {
-  const event = context.events.find((candidate) => candidate.kind === kind);
+  const event = semanticEvents(context).find((candidate) => candidate.kind === kind);
   return event ? [eventEvidence(event, path)] : runEvidence(context.selectedRun);
 }
 function baselineDiffFinding(message, evidence, expected, actual) {
@@ -591,7 +852,7 @@ function createRunStatusRule(options = {}) {
         );
       }
       if (!allowIncomplete) {
-        const running = context.events.filter((event) => event.status === "running");
+        const running = semanticEvents(context).filter((event) => event.status === "running");
         if (running.length > 0) {
           findings.push(
             failFinding(
@@ -634,7 +895,7 @@ function createMaxStepDurationRule(options) {
     category: "run",
     defaultSeverity: "error",
     evaluate(context) {
-      const over = context.events.filter((event) => {
+      const over = semanticEvents(context).filter((event) => {
         const duration = eventDurationMs(event);
         return duration !== void 0 && duration > options.maxDurationMs;
       });
@@ -663,7 +924,7 @@ function createStallDetectionRule(options = {}) {
     defaultSeverity: "warning",
     evaluate(context) {
       const findings = [];
-      const running = context.events.filter((event) => event.status === "running");
+      const running = semanticEvents(context).filter((event) => event.status === "running");
       if (running.length > 0) {
         findings.push(
           failFinding(
@@ -676,7 +937,7 @@ function createStallDetectionRule(options = {}) {
         );
       }
       if (requireEndedAt) {
-        const incomplete = context.events.filter(
+        const incomplete = semanticEvents(context).filter(
           (event) => event.startedAt !== void 0 && event.endedAt === void 0 && event.status !== "running"
         );
         if (incomplete.length > 0) {
@@ -714,7 +975,7 @@ function createRequireCompletedRule() {
           )
         );
       }
-      const running = context.events.filter((event) => event.status === "running");
+      const running = semanticEvents(context).filter((event) => event.status === "running");
       if (running.length > 0) {
         findings.push(
           failFinding(
@@ -736,7 +997,7 @@ function createRunEventCountRule(options) {
     category: "run",
     defaultSeverity: "error",
     evaluate(context) {
-      const count = context.events.filter(
+      const count = semanticEvents(context).filter(
         (event) => options.kind === void 0 || event.kind === options.kind
       ).length;
       const findings = [];
@@ -987,7 +1248,7 @@ function createStructureIncompleteRule(options = {}) {
     evaluate(context) {
       const findings = [];
       if (!options.allowRunning) {
-        const running = context.events.filter((event) => event.status === "running");
+        const running = semanticEvents(context).filter((event) => event.status === "running");
         if (running.length > 0) {
           findings.push(
             failFinding(
@@ -1001,7 +1262,7 @@ function createStructureIncompleteRule(options = {}) {
         }
       }
       if (options.requireEndedAtForStarted) {
-        const missingEndedAt = context.events.filter(
+        const missingEndedAt = semanticEvents(context).filter(
           (event) => event.startedAt !== void 0 && event.endedAt === void 0 && event.status !== "running"
         );
         if (missingEndedAt.length > 0) {
@@ -1027,8 +1288,8 @@ function createStructureOrphanRule(options = {}) {
     category: "structure",
     defaultSeverity: "error",
     evaluate(context) {
-      const byId = eventMap(context.events);
-      const orphans = context.events.filter((event) => {
+      const byId = eventMap(semanticEvents(context));
+      const orphans = semanticEvents(context).filter((event) => {
         if (!event.parentId || byId.has(event.parentId)) return false;
         return !(allowMarkedUnresolved && parentMarkedUnresolved(event));
       });
@@ -1051,10 +1312,10 @@ function createStructureCycleRule() {
     category: "structure",
     defaultSeverity: "error",
     evaluate(context) {
-      const byId = eventMap(context.events);
+      const byId = eventMap(semanticEvents(context));
       const seenCycles = /* @__PURE__ */ new Set();
       const findings = [];
-      for (const event of [...context.events].sort((a, b) => a.eventId.localeCompare(b.eventId))) {
+      for (const event of [...semanticEvents(context)].sort((a, b) => a.eventId.localeCompare(b.eventId))) {
         const path = [];
         const seenAt = /* @__PURE__ */ new Map();
         let current = event;
@@ -1092,10 +1353,10 @@ function createStructureRelationshipRule(options = {}) {
     category: "structure",
     defaultSeverity: "error",
     evaluate(context) {
-      const byId = eventMap(context.events);
+      const byId = eventMap(semanticEvents(context));
       const findings = [];
       const minConfidence = options.minConfidence;
-      for (const event of context.events) {
+      for (const event of semanticEvents(context)) {
         if (minConfidence && CONFIDENCE_RANK[event.confidence] < CONFIDENCE_RANK[minConfidence]) {
           findings.push(
             failFinding(
@@ -1163,7 +1424,7 @@ function createStructureParallelWidthRule(options) {
     defaultSeverity: "error",
     evaluate(context) {
       const findings = [];
-      const byId = eventMap(context.events);
+      const byId = eventMap(semanticEvents(context));
       if (options.maxChildren !== void 0) {
         for (const [parentId, children] of context.childrenByParentId.entries()) {
           if (children.length <= options.maxChildren) continue;
@@ -1190,7 +1451,7 @@ function createStructureParallelWidthRule(options) {
         }
       }
       if (options.maxConcurrent !== void 0) {
-        const intervals = context.events.map((event) => ({ event, start: eventStartMs(event), end: eventEndMs(event) })).filter(
+        const intervals = semanticEvents(context).map((event) => ({ event, start: eventStartMs(event), end: eventEndMs(event) })).filter(
           (item) => item.start !== void 0 && item.end !== void 0 && item.end > item.start
         );
         const points = intervals.flatMap((item) => [
@@ -1486,7 +1747,7 @@ function createSafetyOversizedAttributeRule(options) {
               )
             );
           }
-          if (isRecord(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
+          if (isRecord2(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
             findings.push(
               failFinding(
                 "safety.oversizedAttribute",
@@ -1793,7 +2054,9 @@ function contractToRules(contract) {
           );
         }
         if (!allowIncomplete) {
-          const running = context.events.filter((event) => event.status === "running");
+          const running = (context.logicalEvents ?? context.events).filter(
+            (event) => event.status === "running"
+          );
           if (running.length > 0) {
             findings.push(
               contractFailFinding(
@@ -1899,6 +2162,6 @@ function evaluateTraceContract(input, contract, options = {}) {
   });
 }
 
-export { createBaselineRegressionRule, createDecisionRule, createGuardrailRule, createLlmUsageRule, createMaxStepDurationRule, createObservedOutcomeRule, createRequireCompletedRule, createRetrievalRule, createRunDepthRule, createRunDurationRule, createRunEventCountRule, createRunStatusRule, createSafetyOversizedAttributeRule, createSafetyRawContentRule, createSafetyRedactionRule, createSafetySecretPatternRule, createStallDetectionRule, createStructureCycleRule, createStructureIncompleteRule, createStructureOrphanRule, createStructureParallelWidthRule, createStructureRelationshipRule, createToolFailureRule, createToolOrderingRule, createToolUsageRule, defineTraceContract, evaluateTraceContract, runTraceChecks };
-//# sourceMappingURL=chunk-QT6CQ2XA.mjs.map
-//# sourceMappingURL=chunk-QT6CQ2XA.mjs.map
+export { createBaselineRegressionRule, createDecisionRule, createGuardrailRule, createLlmUsageRule, createMaxStepDurationRule, createObservedOutcomeRule, createRequireCompletedRule, createRetrievalRule, createRunDepthRule, createRunDurationRule, createRunEventCountRule, createRunStatusRule, createSafetyOversizedAttributeRule, createSafetyRawContentRule, createSafetyRedactionRule, createSafetySecretPatternRule, createStallDetectionRule, createStructureCycleRule, createStructureIncompleteRule, createStructureOrphanRule, createStructureParallelWidthRule, createStructureRelationshipRule, createToolFailureRule, createToolOrderingRule, createToolUsageRule, defineTraceContract, evaluateTraceContract, projectLogicalEvents, resolveCanonicalToolName, runTraceChecks };
+//# sourceMappingURL=chunk-KJICERSD.mjs.map
+//# sourceMappingURL=chunk-KJICERSD.mjs.map