agent-inspect 6.30.0 → 6.31.1

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

@@ -1,5 +1,5 @@
-import { L as LogicalTraceEvent, a as LogicalProjectionDiagnostic } from './index-CQJUNPPe.cjs';
-export { B as BaselineRegressionRuleOptions, C as ControlStage, D as DecisionRuleOptions, G as GuardrailRuleOptions, b as LlmUsageRuleOptions, M as MaxStepDurationRuleOptions, O as ObservedOutcomeRuleOptions, R as RecoverySameArgumentsMode, c as RecoverySideEffectClass, d as RetrievalRuleOptions, e as RunDepthRuleOptions, f as RunDurationRuleOptions, g as RunEventCountRuleOptions, h as RunStatusRuleOptions, i as RunTraceChecksOptions, S as SafetyFindingCategory, j as SafetyFindingConfidence, k as SafetyOversizedAttributeRuleOptions, l as SafetyRawContentRuleOptions, m as SafetyRedactionRuleOptions, n as SafetySecretPattern, o as SafetySecretPatternRuleOptions, p as StallDetectionRuleOptions, q as StructureIncompleteRuleOptions, r as StructureOrphanRuleOptions, s as StructureParallelWidthRuleOptions, t as StructureRelationshipRuleOptions, T as ToolArgumentCheck, u as ToolArgumentOccurrence, v as ToolArgumentOperator, w as ToolFailureRuleOptions, x as ToolOrderingRuleOptions, y as ToolUsageRuleOptions, z as TraceCheckContext, A as TraceCheckDiagnostic, E as TraceCheckDiagnosticCode, F as TraceCheckEvidence, H as TraceCheckFacts, I as TraceCheckFinding, J as TraceCheckFindingStatus, K as TraceCheckInput, N as TraceCheckResult, P as TraceCheckRule, Q as TraceCheckRuleCategory, U as TraceCheckRuleExecution, V as TraceCheckRuleExecutionStatus, W as TraceCheckSeverity, X as TraceCheckStatus, Y as TraceCheckSummary, Z as TraceContract, _ as TraceContractAlternativeBranch, $ as TraceContractAlternatives, a0 as TraceContractBody, a1 as TraceContractControlRules, a2 as TraceContractInput, a3 as TraceContractLintDiagnostic, a4 as TraceContractLlmRules, a5 as TraceContractObservationProvenance, a6 as TraceContractObservationRules, a7 as TraceContractRecoveryOperation, a8 as TraceContractRecoveryRetryableErrors, a9 as TraceContractRecoverySuccessfulResultDependency, aa as TraceContractRetryRules, ab as TraceContractRunRules, ac as TraceContractScope, ad as TraceContractToolRules, ae as TraceSignalRuleOptions, af as createBaselineRegressionRule, ag as createDecisionRule, ah as createGuardrailRule, ai as createLlmUsageRule, aj as createMaxStepDurationRule, ak as createObservedOutcomeRule, al as createRequireCompletedRule, am as createRetrievalRule, an as createRunDepthRule, ao as createRunDurationRule, ap as createRunEventCountRule, aq as createRunStatusRule, ar as createSafetyOversizedAttributeRule, as as createSafetyRawContentRule, at as createSafetyRedactionRule, au as createSafetySecretPatternRule, av as createStallDetectionRule, aw as createStructureCycleRule, ax as createStructureIncompleteRule, ay as createStructureOrphanRule, az as createStructureParallelWidthRule, aA as createStructureRelationshipRule, aB as createToolFailureRule, aC as createToolOrderingRule, aD as createToolUsageRule, aE as defineTraceContract, aF as evaluateToolArgumentValue, aG as evaluateTraceContract, aH as evaluateTraceContractRead, aI as explainTraceContract, aJ as extractToolArgumentPayload, aK as lintTraceContract, aL as projectLogicalEvents, aM as resolveCanonicalToolName, aN as resolveJsonPointer, aO as resolveTraceContractScope, aP as runTraceChecks, aQ as workflowMetadataForRun } from './index-CQJUNPPe.cjs';
+import { L as LogicalTraceEvent, a as LogicalProjectionDiagnostic } from './index-EQihlEei.cjs';
+export { B as BaselineRegressionRuleOptions, C as ControlStage, D as DecisionRuleOptions, G as GuardrailRuleOptions, b as LlmUsageRuleOptions, M as MaxStepDurationRuleOptions, O as ObservedOutcomeRuleOptions, R as RecoverySameArgumentsMode, c as RecoverySideEffectClass, d as RetrievalRuleOptions, e as RunDepthRuleOptions, f as RunDurationRuleOptions, g as RunEventCountRuleOptions, h as RunStatusRuleOptions, i as RunTraceChecksOptions, S as SafetyFindingCategory, j as SafetyFindingConfidence, k as SafetyOversizedAttributeRuleOptions, l as SafetyRawContentRuleOptions, m as SafetyRedactionRuleOptions, n as SafetySecretPattern, o as SafetySecretPatternRuleOptions, p as StallDetectionRuleOptions, q as StepOrderingEndpoint, r as StepOrderingKind, s as StepOrderingRuleOptions, t as StructureIncompleteRuleOptions, u as StructureOrphanRuleOptions, v as StructureParallelWidthRuleOptions, w as StructureRelationshipRuleOptions, T as ToolArgumentCheck, x as ToolArgumentOccurrence, y as ToolArgumentOperator, z as ToolFailureRuleOptions, A as ToolOrderingRuleOptions, E as ToolUsageRuleOptions, F as TraceCheckContext, H as TraceCheckDiagnostic, I as TraceCheckDiagnosticCode, J as TraceCheckEvidence, K as TraceCheckFacts, N as TraceCheckFinding, P as TraceCheckFindingStatus, Q as TraceCheckInput, U as TraceCheckResult, V as TraceCheckRule, W as TraceCheckRuleCategory, X as TraceCheckRuleExecution, Y as TraceCheckRuleExecutionStatus, Z as TraceCheckSeverity, _ as TraceCheckStatus, $ as TraceCheckSummary, a0 as TraceContract, a1 as TraceContractAlternativeBranch, a2 as TraceContractAlternatives, a3 as TraceContractBody, a4 as TraceContractControlRules, a5 as TraceContractInput, a6 as TraceContractLintDiagnostic, a7 as TraceContractLlmRules, a8 as TraceContractObservationProvenance, a9 as TraceContractObservationRules, aa as TraceContractRecoveryOperation, ab as TraceContractRecoveryRetryableErrors, ac as TraceContractRecoverySuccessfulResultDependency, ad as TraceContractRetryRules, ae as TraceContractRunRules, af as TraceContractScope, ag as TraceContractStepKind, ah as TraceContractStepOrderRelation, ai as TraceContractStepRef, aj as TraceContractStepRules, ak as TraceContractToolRules, al as TraceSignalRuleOptions, am as createBaselineRegressionRule, an as createDecisionRule, ao as createGuardrailRule, ap as createLlmUsageRule, aq as createMaxStepDurationRule, ar as createObservedOutcomeRule, as as createRequireCompletedRule, at as createRetrievalRule, au as createRunDepthRule, av as createRunDurationRule, aw as createRunEventCountRule, ax as createRunStatusRule, ay as createSafetyOversizedAttributeRule, az as createSafetyRawContentRule, aA as createSafetyRedactionRule, aB as createSafetySecretPatternRule, aC as createStallDetectionRule, aD as createStepOrderingRule, aE as createStructureCycleRule, aF as createStructureIncompleteRule, aG as createStructureOrphanRule, aH as createStructureParallelWidthRule, aI as createStructureRelationshipRule, aJ as createToolFailureRule, aK as createToolOrderingRule, aL as createToolUsageRule, aM as defineTraceContract, aN as evaluateToolArgumentValue, aO as evaluateTraceContract, aP as evaluateTraceContractRead, aQ as explainTraceContract, aR as extractToolArgumentPayload, aS as lintTraceContract, aT as projectLogicalEvents, aU as resolveCanonicalToolName, aV as resolveJsonPointer, aW as resolveTraceContractScope, aX as runTraceChecks, aY as workflowMetadataForRun } from './index-EQihlEei.cjs';
 export { b as ATTRIBUTION_CONFIDENCES, c as ATTRIBUTION_CONFIDENCE_RANK, A as AttributionConfidence, i as isAttributionConfidence } from './inspect-event-ClM5Z8om.cjs';
 export { P as PROGRAMMATIC_DIAGNOSTIC_SPECS, a as ProgrammaticDiagnosticCode, b as ProgrammaticDiagnosticSpec, f as formatProgrammaticDiagnostic } from './programmatic-gZTWLObB.cjs';
 import { g as TraceReadResult } from './index-Cdww9h50.cjs';

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

@@ -1,5 +1,5 @@
-import { L as LogicalTraceEvent, a as LogicalProjectionDiagnostic } from './index-7hG_qggp.js';
-export { B as BaselineRegressionRuleOptions, C as ControlStage, D as DecisionRuleOptions, G as GuardrailRuleOptions, b as LlmUsageRuleOptions, M as MaxStepDurationRuleOptions, O as ObservedOutcomeRuleOptions, R as RecoverySameArgumentsMode, c as RecoverySideEffectClass, d as RetrievalRuleOptions, e as RunDepthRuleOptions, f as RunDurationRuleOptions, g as RunEventCountRuleOptions, h as RunStatusRuleOptions, i as RunTraceChecksOptions, S as SafetyFindingCategory, j as SafetyFindingConfidence, k as SafetyOversizedAttributeRuleOptions, l as SafetyRawContentRuleOptions, m as SafetyRedactionRuleOptions, n as SafetySecretPattern, o as SafetySecretPatternRuleOptions, p as StallDetectionRuleOptions, q as StructureIncompleteRuleOptions, r as StructureOrphanRuleOptions, s as StructureParallelWidthRuleOptions, t as StructureRelationshipRuleOptions, T as ToolArgumentCheck, u as ToolArgumentOccurrence, v as ToolArgumentOperator, w as ToolFailureRuleOptions, x as ToolOrderingRuleOptions, y as ToolUsageRuleOptions, z as TraceCheckContext, A as TraceCheckDiagnostic, E as TraceCheckDiagnosticCode, F as TraceCheckEvidence, H as TraceCheckFacts, I as TraceCheckFinding, J as TraceCheckFindingStatus, K as TraceCheckInput, N as TraceCheckResult, P as TraceCheckRule, Q as TraceCheckRuleCategory, U as TraceCheckRuleExecution, V as TraceCheckRuleExecutionStatus, W as TraceCheckSeverity, X as TraceCheckStatus, Y as TraceCheckSummary, Z as TraceContract, _ as TraceContractAlternativeBranch, $ as TraceContractAlternatives, a0 as TraceContractBody, a1 as TraceContractControlRules, a2 as TraceContractInput, a3 as TraceContractLintDiagnostic, a4 as TraceContractLlmRules, a5 as TraceContractObservationProvenance, a6 as TraceContractObservationRules, a7 as TraceContractRecoveryOperation, a8 as TraceContractRecoveryRetryableErrors, a9 as TraceContractRecoverySuccessfulResultDependency, aa as TraceContractRetryRules, ab as TraceContractRunRules, ac as TraceContractScope, ad as TraceContractToolRules, ae as TraceSignalRuleOptions, af as createBaselineRegressionRule, ag as createDecisionRule, ah as createGuardrailRule, ai as createLlmUsageRule, aj as createMaxStepDurationRule, ak as createObservedOutcomeRule, al as createRequireCompletedRule, am as createRetrievalRule, an as createRunDepthRule, ao as createRunDurationRule, ap as createRunEventCountRule, aq as createRunStatusRule, ar as createSafetyOversizedAttributeRule, as as createSafetyRawContentRule, at as createSafetyRedactionRule, au as createSafetySecretPatternRule, av as createStallDetectionRule, aw as createStructureCycleRule, ax as createStructureIncompleteRule, ay as createStructureOrphanRule, az as createStructureParallelWidthRule, aA as createStructureRelationshipRule, aB as createToolFailureRule, aC as createToolOrderingRule, aD as createToolUsageRule, aE as defineTraceContract, aF as evaluateToolArgumentValue, aG as evaluateTraceContract, aH as evaluateTraceContractRead, aI as explainTraceContract, aJ as extractToolArgumentPayload, aK as lintTraceContract, aL as projectLogicalEvents, aM as resolveCanonicalToolName, aN as resolveJsonPointer, aO as resolveTraceContractScope, aP as runTraceChecks, aQ as workflowMetadataForRun } from './index-7hG_qggp.js';
+import { L as LogicalTraceEvent, a as LogicalProjectionDiagnostic } from './index-CgOAGuM5.js';
+export { B as BaselineRegressionRuleOptions, C as ControlStage, D as DecisionRuleOptions, G as GuardrailRuleOptions, b as LlmUsageRuleOptions, M as MaxStepDurationRuleOptions, O as ObservedOutcomeRuleOptions, R as RecoverySameArgumentsMode, c as RecoverySideEffectClass, d as RetrievalRuleOptions, e as RunDepthRuleOptions, f as RunDurationRuleOptions, g as RunEventCountRuleOptions, h as RunStatusRuleOptions, i as RunTraceChecksOptions, S as SafetyFindingCategory, j as SafetyFindingConfidence, k as SafetyOversizedAttributeRuleOptions, l as SafetyRawContentRuleOptions, m as SafetyRedactionRuleOptions, n as SafetySecretPattern, o as SafetySecretPatternRuleOptions, p as StallDetectionRuleOptions, q as StepOrderingEndpoint, r as StepOrderingKind, s as StepOrderingRuleOptions, t as StructureIncompleteRuleOptions, u as StructureOrphanRuleOptions, v as StructureParallelWidthRuleOptions, w as StructureRelationshipRuleOptions, T as ToolArgumentCheck, x as ToolArgumentOccurrence, y as ToolArgumentOperator, z as ToolFailureRuleOptions, A as ToolOrderingRuleOptions, E as ToolUsageRuleOptions, F as TraceCheckContext, H as TraceCheckDiagnostic, I as TraceCheckDiagnosticCode, J as TraceCheckEvidence, K as TraceCheckFacts, N as TraceCheckFinding, P as TraceCheckFindingStatus, Q as TraceCheckInput, U as TraceCheckResult, V as TraceCheckRule, W as TraceCheckRuleCategory, X as TraceCheckRuleExecution, Y as TraceCheckRuleExecutionStatus, Z as TraceCheckSeverity, _ as TraceCheckStatus, $ as TraceCheckSummary, a0 as TraceContract, a1 as TraceContractAlternativeBranch, a2 as TraceContractAlternatives, a3 as TraceContractBody, a4 as TraceContractControlRules, a5 as TraceContractInput, a6 as TraceContractLintDiagnostic, a7 as TraceContractLlmRules, a8 as TraceContractObservationProvenance, a9 as TraceContractObservationRules, aa as TraceContractRecoveryOperation, ab as TraceContractRecoveryRetryableErrors, ac as TraceContractRecoverySuccessfulResultDependency, ad as TraceContractRetryRules, ae as TraceContractRunRules, af as TraceContractScope, ag as TraceContractStepKind, ah as TraceContractStepOrderRelation, ai as TraceContractStepRef, aj as TraceContractStepRules, ak as TraceContractToolRules, al as TraceSignalRuleOptions, am as createBaselineRegressionRule, an as createDecisionRule, ao as createGuardrailRule, ap as createLlmUsageRule, aq as createMaxStepDurationRule, ar as createObservedOutcomeRule, as as createRequireCompletedRule, at as createRetrievalRule, au as createRunDepthRule, av as createRunDurationRule, aw as createRunEventCountRule, ax as createRunStatusRule, ay as createSafetyOversizedAttributeRule, az as createSafetyRawContentRule, aA as createSafetyRedactionRule, aB as createSafetySecretPatternRule, aC as createStallDetectionRule, aD as createStepOrderingRule, aE as createStructureCycleRule, aF as createStructureIncompleteRule, aG as createStructureOrphanRule, aH as createStructureParallelWidthRule, aI as createStructureRelationshipRule, aJ as createToolFailureRule, aK as createToolOrderingRule, aL as createToolUsageRule, aM as defineTraceContract, aN as evaluateToolArgumentValue, aO as evaluateTraceContract, aP as evaluateTraceContractRead, aQ as explainTraceContract, aR as extractToolArgumentPayload, aS as lintTraceContract, aT as projectLogicalEvents, aU as resolveCanonicalToolName, aV as resolveJsonPointer, aW as resolveTraceContractScope, aX as runTraceChecks, aY as workflowMetadataForRun } from './index-CgOAGuM5.js';
 export { b as ATTRIBUTION_CONFIDENCES, c as ATTRIBUTION_CONFIDENCE_RANK, A as AttributionConfidence, i as isAttributionConfidence } from './inspect-event-ClM5Z8om.js';
 export { P as PROGRAMMATIC_DIAGNOSTIC_SPECS, a as ProgrammaticDiagnosticCode, b as ProgrammaticDiagnosticSpec, f as formatProgrammaticDiagnostic } from './programmatic-gZTWLObB.js';
 import { g as TraceReadResult } from './index-xUbdpcrP.js';

package/packages/core/dist/checks.mjs

@@ -1,4 +1,4 @@
-export { buildTraceFacts, 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, deriveFailureFacts, deriveRelationshipFacts, evaluateToolArgumentValue, evaluateTraceContract, evaluateTraceContractRead, explainTraceContract, extractToolArgumentPayload, lintTraceContract, projectLogicalEvents, resolveCanonicalToolName, resolveJsonPointer, resolveTraceContractScope, runTraceChecks, summarizeSemanticParity, workflowMetadataForRun } from './chunk-OOX25GTH.mjs';
+export { buildTraceFacts, createBaselineRegressionRule, createDecisionRule, createGuardrailRule, createLlmUsageRule, createMaxStepDurationRule, createObservedOutcomeRule, createRequireCompletedRule, createRetrievalRule, createRunDepthRule, createRunDurationRule, createRunEventCountRule, createRunStatusRule, createSafetyOversizedAttributeRule, createSafetyRawContentRule, createSafetyRedactionRule, createSafetySecretPatternRule, createStallDetectionRule, createStepOrderingRule, createStructureCycleRule, createStructureIncompleteRule, createStructureOrphanRule, createStructureParallelWidthRule, createStructureRelationshipRule, createToolFailureRule, createToolOrderingRule, createToolUsageRule, defineTraceContract, deriveFailureFacts, deriveRelationshipFacts, evaluateToolArgumentValue, evaluateTraceContract, evaluateTraceContractRead, explainTraceContract, extractToolArgumentPayload, lintTraceContract, projectLogicalEvents, resolveCanonicalToolName, resolveJsonPointer, resolveTraceContractScope, runTraceChecks, summarizeSemanticParity, workflowMetadataForRun } from './chunk-CBPWLHNQ.mjs';
 import './chunk-BGF5JDJN.mjs';
 import './chunk-PBNBQRXV.mjs';
 import './chunk-VU6O5QAH.mjs';

package/packages/core/dist/{chunk-OOX25GTH.mjs → chunk-CBPWLHNQ.mjs}

@@ -2354,11 +2354,40 @@ function contractFailFinding(ruleId, message, evidence, expected, actual) {
     evidence: [...evidence]
   };
 }
+var ALLOWED_STATUS_ALIASES = {
+  ok: "ok",
+  error: "error",
+  running: "running",
+  success: "ok",
+  failed: "error"
+};
+function parseAllowedStatus(status) {
+  return ALLOWED_STATUS_ALIASES[status];
+}
 function normalizeStatus(status) {
-  if (status === "ok" || status === "error" || status === "running") return status;
-  if (status === "success") return "ok";
-  if (status === "failed") return "error";
-  return "error";
+  const parsed = parseAllowedStatus(status);
+  if (parsed === void 0) {
+    throw new TypeError(
+      `Unknown run status ${JSON.stringify(status)}. Allowed: ok, error, running (aliases: success, failed).`
+    );
+  }
+  return parsed;
+}
+function validateAllowedStatusesShape(allowedStatuses, pathPrefix = "run.allowedStatuses") {
+  if (!allowedStatuses?.length) return [];
+  const out = [];
+  for (let i = 0; i < allowedStatuses.length; i++) {
+    const status = allowedStatuses[i];
+    if (parseAllowedStatus(status) === void 0) {
+      out.push({
+        code: "contract.run.allowedStatuses.unknown",
+        severity: "error",
+        message: `${pathPrefix}[${i}] has unknown status ${JSON.stringify(status)}. Allowed: ok, error, running (aliases: success, failed).`,
+        path: `${pathPrefix}[${i}]`
+      });
+    }
+  }
+  return out;
 }
 function cloneBody(body) {
   return {
@@ -2371,6 +2400,17 @@ function cloneBody(body) {
       }
     } : {},
     ...body.llm ? { llm: { ...body.llm } } : {},
+    ...body.steps ? {
+      steps: {
+        ...body.steps.orderRelations ? {
+          orderRelations: body.steps.orderRelations.map((item) => ({
+            ...item,
+            before: { ...item.before },
+            after: { ...item.after }
+          }))
+        } : {}
+      }
+    } : {},
     ...body.observations ? {
       observations: {
         ...body.observations,
@@ -2410,7 +2450,7 @@ function cloneBody(body) {
   };
 }
 function bodyHasRules(body) {
-  return body.run !== void 0 || body.tools !== void 0 || body.llm !== void 0 || body.observations !== void 0 || body.controls !== void 0 || body.retry !== void 0;
+  return body.run !== void 0 || body.tools !== void 0 || body.llm !== void 0 || body.steps !== void 0 || body.observations !== void 0 || body.controls !== void 0 || body.retry !== void 0;
 }
 var MAX_EVIDENCE_EVENT_IDS = 16;
 var METHOD_VOCABULARY = new Set(OBSERVED_OUTCOME_METHODS);
@@ -2753,6 +2793,18 @@ function contractToRules(contract) {
       })
     );
   }
+  const orderRelations = contract.steps?.orderRelations ?? [];
+  for (const [index, relation] of orderRelations.entries()) {
+    rules.push(
+      createStepOrderingRule({
+        before: { kind: relation.before.kind, name: relation.before.name },
+        after: { kind: relation.after.kind, name: relation.after.name },
+        id: `contract.step.orderRelation.${index}`,
+        mode: relation.mode ?? "first-occurrence",
+        requireEndpoints: relation.requireEndpoints !== false
+      })
+    );
+  }
   if (contract.observations) {
     const required = contract.observations.required ?? [];
     if (required.length > 0) {
@@ -3002,6 +3054,7 @@ function evaluateBody(input, body, options = {}) {
 }
 function defineTraceContract(input) {
   const shapeErrors = [
+    ...validateAllowedStatusesShape(input.run?.allowedStatuses),
     ...validateAlternativesShape(input.alternatives),
     ...validateScopeShape(input.scope),
     ...validateProvenanceShape(input.observations)
@@ -3032,6 +3085,7 @@ function defineTraceContract(input) {
 }
 function evaluateTraceContract(input, contract, options = {}) {
   const shapeErrors = [
+    ...validateAllowedStatusesShape(contract.run?.allowedStatuses),
     ...validateAlternativesShape(contract.alternatives),
     ...validateScopeShape(contract.scope),
     ...validateProvenanceShape(contract.observations)
@@ -3306,6 +3360,13 @@ function explainTraceContract(contract) {
       lines.push(`Base: LLM allowedModels [${contract.llm.allowedModels.join(", ")}].`);
     }
   }
+  if ((contract.steps?.orderRelations?.length ?? 0) > 0) {
+    const relations = contract.steps.orderRelations;
+    const summary = relations.map(
+      (relation) => `${relation.before.kind}:${relation.before.name} \u2192 ${relation.after.kind}:${relation.after.name} mode=${relation.mode ?? "first-occurrence"}`
+    ).join("; ");
+    lines.push(`Base: ${relations.length} steps.orderRelations [${summary}].`);
+  }
   if (contract.observations?.required?.length) {
     lines.push(`Base: required observations [${contract.observations.required.join(", ")}].`);
   }
@@ -3720,6 +3781,31 @@ function failFinding(ruleId, message, evidence, expected, actual, meta) {
 function toolName(event) {
   return resolveCanonicalToolName(event);
 }
+function stepEndpointName(event, kind) {
+  if (kind === "TOOL") return resolveCanonicalToolName(event);
+  for (const prefix of ["llm:", "generation:", "transcription:", "speech:"]) {
+    if (event.name.startsWith(prefix)) return event.name.slice(prefix.length);
+  }
+  return event.name;
+}
+function formatStepEndpoint(endpoint) {
+  return `${endpoint.kind} ${endpoint.name}`;
+}
+function otherKindsForStepName(context, expectedKind, name) {
+  return [
+    ...new Set(
+      semanticEvents(context).filter((event) => {
+        const kind = typeof event.kind === "string" ? event.kind.toUpperCase() : "";
+        if (kind === expectedKind) return false;
+        if (kind === "TOOL") return resolveCanonicalToolName(event) === name;
+        if (kind === "LLM") return stepEndpointName(event, "LLM") === name;
+        return event.name === name || event.name === `tool:${name}` || event.name === `llm:${name}` || event.name.endsWith(`:${name}`);
+      }).map(
+        (event) => typeof event.kind === "string" ? event.kind.toUpperCase() : "UNKNOWN"
+      )
+    )
+  ].sort();
+}
 function semanticEvents(context) {
   return context.logicalEvents ?? context.events;
 }
@@ -3746,14 +3832,6 @@ function finishedEvents(context, kind) {
 function toolInvocationEvents(context) {
   return semanticEvents(context).filter((event) => event.kind === "TOOL");
 }
-function firstIndexByName(events) {
-  const index = /* @__PURE__ */ new Map();
-  for (const [position, event] of events.entries()) {
-    const name = toolName(event);
-    if (!index.has(name)) index.set(name, position);
-  }
-  return index;
-}
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -4263,18 +4341,85 @@ function createToolUsageRule(options) {
     }
   };
 }
-function createToolOrderingRule(options) {
-  const ruleId = options.id ?? "tool.order";
+function createStepOrderingRule(options) {
+  const bothTools = options.before.kind === "TOOL" && options.after.kind === "TOOL";
+  const ruleId = options.id ?? (bothTools ? "tool.order" : "step.order");
   const mode = options.mode ?? "first-occurrence";
+  const requireEndpoints = options.requireEndpoints === true;
+  const beforeLabel = bothTools ? options.before.name : formatStepEndpoint(options.before);
+  const afterLabel = bothTools ? options.after.name : formatStepEndpoint(options.after);
+  const subject = bothTools ? "Tool" : "Step";
   return {
     id: ruleId,
-    category: "tool",
+    category: bothTools ? "tool" : "structure",
     defaultSeverity: "error",
     evaluate(context) {
-      const tools = finishedEvents(context, "TOOL");
-      const index = firstIndexByName(tools);
-      const beforeIndex = index.get(options.before);
-      const afterIndex = index.get(options.after);
+      const beforeEvents = finishedEvents(context, options.before.kind).filter(
+        (event) => stepEndpointName(event, options.before.kind) === options.before.name
+      );
+      const afterEvents = finishedEvents(context, options.after.kind).filter(
+        (event) => stepEndpointName(event, options.after.kind) === options.after.name
+      );
+      if (beforeEvents.length === 0 || afterEvents.length === 0) {
+        if (!requireEndpoints) return [];
+        const findings = [];
+        if (beforeEvents.length === 0) {
+          const otherKinds = otherKindsForStepName(
+            context,
+            options.before.kind,
+            options.before.name
+          );
+          const hint = otherKinds.length > 0 ? ` Required name appears under non-${options.before.kind} kind(s): ${otherKinds.join(", ")}.` : "";
+          findings.push(
+            failFinding(
+              ruleId,
+              `Required ${formatStepEndpoint(options.before)} did not appear.${hint}`,
+              runEvidence(context.selectedRun),
+              options.before,
+              {
+                code: bothTools ? "tool.order.missing-endpoint" : "step.order.missing-endpoint",
+                endpoint: "before",
+                otherKinds
+              }
+            )
+          );
+        }
+        if (afterEvents.length === 0) {
+          const otherKinds = otherKindsForStepName(
+            context,
+            options.after.kind,
+            options.after.name
+          );
+          const hint = otherKinds.length > 0 ? ` Required name appears under non-${options.after.kind} kind(s): ${otherKinds.join(", ")}.` : "";
+          findings.push(
+            failFinding(
+              ruleId,
+              `Required ${formatStepEndpoint(options.after)} did not appear.${hint}`,
+              runEvidence(context.selectedRun),
+              options.after,
+              {
+                code: bothTools ? "tool.order.missing-endpoint" : "step.order.missing-endpoint",
+                endpoint: "after",
+                otherKinds
+              }
+            )
+          );
+        }
+        return findings;
+      }
+      const encounter = finishedEvents(context).filter(
+        (event) => event.kind === options.before.kind && stepEndpointName(event, options.before.kind) === options.before.name || event.kind === options.after.kind && stepEndpointName(event, options.after.kind) === options.after.name
+      );
+      let beforeIndex;
+      let afterIndex;
+      for (const [position, event] of encounter.entries()) {
+        if (beforeIndex === void 0 && event.kind === options.before.kind && stepEndpointName(event, options.before.kind) === options.before.name) {
+          beforeIndex = position;
+        }
+        if (afterIndex === void 0 && event.kind === options.after.kind && stepEndpointName(event, options.after.kind) === options.after.name) {
+          afterIndex = position;
+        }
+      }
       if (beforeIndex === void 0 || afterIndex === void 0) {
         return [];
       }
@@ -4282,32 +4427,37 @@ function createToolOrderingRule(options) {
         return [
           failFinding(
             ruleId,
-            `Tool ${options.before} must appear before ${options.after}.`,
-            [eventEvidence3(tools[beforeIndex]), eventEvidence3(tools[afterIndex])],
-            { before: options.before, after: options.after },
-            tools.map(toolName)
+            `${subject} ${beforeLabel} must appear before ${afterLabel}.`,
+            [
+              eventEvidence3(encounter[beforeIndex]),
+              eventEvidence3(encounter[afterIndex])
+            ],
+            bothTools ? { before: options.before.name, after: options.after.name } : { before: options.before, after: options.after },
+            bothTools ? finishedEvents(context, "TOOL").map(toolName) : encounter.map(
+              (event) => event.kind === "TOOL" || event.kind === "LLM" ? `${event.kind}:${stepEndpointName(event, event.kind)}` : event.name
+            )
           )
         ];
       }
-      const beforeEvent = tools[beforeIndex];
-      const afterEvent = tools[afterIndex];
+      const beforeEvent = beforeEvents[0];
+      const afterEvent = afterEvents[0];
       const beforeEnd = eventEndMs(beforeEvent);
       const afterStart = eventStartMs(afterEvent);
+      const endpointExpected = bothTools ? { before: options.before.name, after: options.after.name } : { before: options.before, after: options.after };
       if (mode === "happens-before") {
         const expected = {
-          before: options.before,
-          after: options.after,
+          ...endpointExpected,
           mode,
           relation: "before.end <= after.start"
         };
-        if (options.before === options.after) {
+        if (options.before.kind === options.after.kind && options.before.name === options.after.name) {
           return [
             failFinding(
               ruleId,
-              `Tool ${options.before} cannot causally happen before itself.`,
+              `${subject} ${beforeLabel} cannot causally happen before itself.`,
               [eventEvidence3(beforeEvent)],
               expected,
-              { code: "tool.order.same-tool" }
+              { code: bothTools ? "tool.order.same-tool" : "step.order.same-step" }
             )
           ];
         }
@@ -4315,11 +4465,11 @@ function createToolOrderingRule(options) {
           return [
             failFinding(
               ruleId,
-              `Tool order ${options.before} before ${options.after} could not establish causal timing.`,
+              `${subject} order ${beforeLabel} before ${afterLabel} could not establish causal timing.`,
               [eventEvidence3(beforeEvent), eventEvidence3(afterEvent)],
               expected,
               {
-                code: "tool.order.interval-unresolved",
+                code: bothTools ? "tool.order.interval-unresolved" : "step.order.interval-unresolved",
                 beforeEndResolved: beforeEnd !== void 0,
                 afterStartResolved: afterStart !== void 0
               }
@@ -4330,7 +4480,7 @@ function createToolOrderingRule(options) {
           return [
             failFinding(
               ruleId,
-              `Tool ${options.before} must finish before ${options.after} starts.`,
+              `${subject} ${beforeLabel} must finish before ${afterLabel} starts.`,
               [eventEvidence3(beforeEvent), eventEvidence3(afterEvent)],
               expected,
               {
@@ -4343,22 +4493,19 @@ function createToolOrderingRule(options) {
         return [];
       }
       if (mode === "all-occurrences") {
-        const beforeEvents = tools.filter((event) => toolName(event) === options.before);
-        const afterEvents = tools.filter((event) => toolName(event) === options.after);
         const expected = {
-          before: options.before,
-          after: options.after,
+          ...endpointExpected,
           mode,
           relation: "max(before.end) <= min(after.start)"
         };
-        if (options.before === options.after) {
+        if (options.before.kind === options.after.kind && options.before.name === options.after.name) {
           return [
             failFinding(
               ruleId,
-              `Tool ${options.before} cannot causally happen before itself.`,
+              `${subject} ${beforeLabel} cannot causally happen before itself.`,
               [eventEvidence3(beforeEvent)],
               expected,
-              { code: "tool.order.same-tool" }
+              { code: bothTools ? "tool.order.same-tool" : "step.order.same-step" }
             )
           ];
         }
@@ -4390,11 +4537,11 @@ function createToolOrderingRule(options) {
           return [
             failFinding(
               ruleId,
-              `Tool order ${options.before} before ${options.after} could not establish all causal intervals.`,
+              `${subject} order ${beforeLabel} before ${afterLabel} could not establish all causal intervals.`,
               [firstMissingBefore, firstMissingAfter].filter((event) => event !== void 0).map((event) => eventEvidence3(event)),
               expected,
               {
-                code: "tool.order.interval-unresolved",
+                code: bothTools ? "tool.order.interval-unresolved" : "step.order.interval-unresolved",
                 missingBeforeEnds,
                 missingAfterStarts
               }
@@ -4405,7 +4552,7 @@ function createToolOrderingRule(options) {
           return [
             failFinding(
               ruleId,
-              `Every ${options.before} tool call must finish before any ${options.after} tool call starts.`,
+              bothTools ? `Every ${options.before.name} tool call must finish before any ${options.after.name} tool call starts.` : `Every ${beforeLabel} must finish before any ${afterLabel} starts.`,
               [eventEvidence3(latestBefore.event), eventEvidence3(earliestAfter.event)],
               expected,
               {
@@ -4423,10 +4570,13 @@ function createToolOrderingRule(options) {
             ruleId,
             severity: "warning",
             status: "warning",
-            message: `Tool order ${options.before} before ${options.after} satisfied start/encounter order, but intervals overlap so causal completion before the next tool was not established.`,
-            expected: { before: options.before, after: options.after, mode: "first-occurrence" },
+            message: `${subject} order ${beforeLabel} before ${afterLabel} satisfied start/encounter order, but intervals overlap so causal completion before the next ${bothTools ? "tool" : "step"} was not established.`,
+            expected: {
+              ...endpointExpected,
+              mode: "first-occurrence"
+            },
             actual: {
-              code: "tool.order.overlap",
+              code: bothTools ? "tool.order.overlap" : "step.order.overlap",
               beforeEndedAt: beforeEvent.endedAt,
               afterStartedAt: afterEvent.startedAt ?? afterEvent.timestamp
             },
@@ -4438,6 +4588,15 @@ function createToolOrderingRule(options) {
     }
   };
 }
+function createToolOrderingRule(options) {
+  return createStepOrderingRule({
+    before: { kind: "TOOL", name: options.before },
+    after: { kind: "TOOL", name: options.after },
+    ...options.id !== void 0 ? { id: options.id } : {},
+    ...options.mode !== void 0 ? { mode: options.mode } : {},
+    requireEndpoints: false
+  });
+}
 function createToolFailureRule(options) {
   return {
     id: "tool.failures",
@@ -5360,6 +5519,6 @@ function runTraceChecks(input, options = {}) {
   };
 }
 
-export { buildTraceFacts, 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, deriveFailureFacts, deriveRelationshipFacts, evaluateToolArgumentValue, evaluateTraceContract, evaluateTraceContractRead, explainTraceContract, extractSessionWorkflowMetadata, extractToolArgumentPayload, lintTraceContract, projectLogicalEvents, resolveCanonicalToolName, resolveJsonPointer, resolveTraceContractScope, runTraceChecks, sessionKeyForRun, summarizeSemanticParity, workflowMetadataForRun };
-//# sourceMappingURL=chunk-OOX25GTH.mjs.map
-//# sourceMappingURL=chunk-OOX25GTH.mjs.map
+export { buildTraceFacts, createBaselineRegressionRule, createDecisionRule, createGuardrailRule, createLlmUsageRule, createMaxStepDurationRule, createObservedOutcomeRule, createRequireCompletedRule, createRetrievalRule, createRunDepthRule, createRunDurationRule, createRunEventCountRule, createRunStatusRule, createSafetyOversizedAttributeRule, createSafetyRawContentRule, createSafetyRedactionRule, createSafetySecretPatternRule, createStallDetectionRule, createStepOrderingRule, createStructureCycleRule, createStructureIncompleteRule, createStructureOrphanRule, createStructureParallelWidthRule, createStructureRelationshipRule, createToolFailureRule, createToolOrderingRule, createToolUsageRule, defineTraceContract, deriveFailureFacts, deriveRelationshipFacts, evaluateToolArgumentValue, evaluateTraceContract, evaluateTraceContractRead, explainTraceContract, extractSessionWorkflowMetadata, extractToolArgumentPayload, lintTraceContract, projectLogicalEvents, resolveCanonicalToolName, resolveJsonPointer, resolveTraceContractScope, runTraceChecks, sessionKeyForRun, summarizeSemanticParity, workflowMetadataForRun };
+//# sourceMappingURL=chunk-CBPWLHNQ.mjs.map
+//# sourceMappingURL=chunk-CBPWLHNQ.mjs.map