agent-inspect 6.30.0 → 6.31.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 6.31.1
+
+### Patch Changes
+
+- 11a0159: Strict `allowedStatuses` validation (typos like `succes` no longer map to permissive `error`); portable `prepublishOnly` skip runner for Trusted Publish; LangChain `handleChainStart` parentage matches CallbackManager runtime arg order.
+
+## 6.31.0
+
+### Minor Changes
+
+- 11a8b90: Add TraceContract `steps.orderRelations` for typed TOOL↔LLM step ordering (additive; TOOL-only `requiredOrder` / `orderRules` unchanged).
+
 ## 6.30.0
 
 ### Minor Changes

package/README.md

@@ -212,7 +212,7 @@ The root package is enough for custom capture, the CLI, checks, and Evidence wor
 
 ## Status and documentation
 
-**Current published baseline:** **6.30.0** · persisted schema `1.0` · Node.js `>=20` · MIT.
+**Current published baseline:** **6.31.1** · persisted schema `1.0` · Node.js `>=20` · MIT.
 
 Legacy v0.1 and v0.2 traces remain readable. Check the npm badge and [changelog](CHANGELOG.md) for the current published version.
 

package/docs/COMPARE.md

@@ -120,7 +120,7 @@ AgentInspect avoids SDK/collector setup for local debugging:
 
 ## v3.5 positioning (local inner loop)
 
-AgentInspect v3.5 is the **adoption release**. The npm map is one core package (`agent-inspect`: APIs + CLI) plus optional packages that stay out of the root dependency graph: framework adapters (`ai-sdk`, `openai-agents`, `langchain`, `mcp`, `adapter-sdk`), CI and quality gates (`vitest`, `jest`, `eval`, `guardrails`, `circuit`, `harness`), and inspection surfaces (`viewer`, `tui`, `mcp-server`, `redact`). See the [package map](../README.md#package-map).
+AgentInspect v3.5 is the **adoption release**. The npm map is one core package (`agent-inspect`: APIs + CLI) plus optional packages that stay out of the root dependency graph: framework adapters (`ai-sdk`, `openai-agents`, `langchain`, `mcp`, `adapter-sdk`), CI and quality gates (`vitest`, `jest`, `eval`, `guardrails`, `circuit`, `harness`), and inspection surfaces (`viewer`, `tui`, `mcp-server`, `redact`). See the [package map](https://github.com/rajudandigam/agent-inspect#package-map).
 
 Use it when:
 

package/docs/FIRST-TRACE-IN-5-MINUTES.md

@@ -1,6 +1,6 @@
 # First trace in 5 minutes
 
-Goal: install → one trace → one check → one share-safe bundle.
+Goal: install → one trace → one trajectory check → one share-safe Evidence bundle.
 
 **Docs site:** [https://agentinspect.vercel.app/docs/getting-started/](https://agentinspect.vercel.app/docs/getting-started/)
 
@@ -14,12 +14,15 @@ npx agent-inspect list --dir .agent-inspect
 Copy a `<run-id>` from `list`, then:
 
 ```bash
-npx agent-inspect report <run-id> --dir .agent-inspect
-npx agent-inspect check <run-id> --dir .agent-inspect
-npx agent-inspect bundle <run-id> --dir .agent-inspect --profile share
+npx agent-inspect view <run-id> --dir .agent-inspect --summary
+npx agent-inspect check <run-id> --dir .agent-inspect --preset trajectory
 npx agent-inspect verify-safe <run-id> --dir .agent-inspect
+npx agent-inspect bundle <run-id> --dir .agent-inspect --profile share --out ./evidence
+npx agent-inspect bundle verify ./evidence
 ```
 
+`init` scaffolds files into the current directory (`agent-inspect.config.ts`, `.agent-inspect/`, and `examples/agent-inspect-demo.mjs`). It does **not** install dependencies or write a trace by itself. Use `--preset trajectory` for structural CI gates; `--fail-on-observation` belongs only in examples that record explicit OUTCOME events.
+
 ## Minutes 0–1: Install
 
 ```bash
@@ -28,9 +31,6 @@ npm install agent-inspect
 npx agent-inspect init --yes
 ```
 
-Creates `agent-inspect.config.ts`, `.agent-inspect/`, and `examples/agent-inspect-demo.mjs`.  
-`init` scaffolds files; it does **not** write a trace by itself.
-
 Framework users: pick the correct capture path first — [CHOOSE-YOUR-CAPTURE-PATH.md](./CHOOSE-YOUR-CAPTURE-PATH.md).
 
 ## Minutes 1–2: Run
@@ -39,33 +39,36 @@ Framework users: pick the correct capture path first — [CHOOSE-YOUR-CAPTURE-PA
 node examples/agent-inspect-demo.mjs
 ```
 
-No API keys. Deterministic local trace.
+No API keys. Deterministic local trace under `.agent-inspect/`.
 
 ## Minutes 2–3: Inspect
 
 ```bash
 npx agent-inspect list --dir .agent-inspect
-npx agent-inspect view <run-id> --dir .agent-inspect
-npx agent-inspect report <run-id> --dir .agent-inspect
+npx agent-inspect view <run-id> --dir .agent-inspect --summary
 ```
 
+Replace `<run-id>` with the ID printed by `list` (do not guess “latest file”).
+
 ## Minutes 3–4: Check
 
 ```bash
-npx agent-inspect check <run-id> --dir .agent-inspect
+npx agent-inspect check <run-id> --dir .agent-inspect --preset trajectory
 ```
 
+Expected exit code `0` for the keyless demo. Add `--required-tool <name>` only when that tool is part of the real expected workflow.
+
 ## Minutes 4–5: Share-safe artifact
 
 ```bash
-npx agent-inspect bundle <run-id> --dir .agent-inspect --profile share
 npx agent-inspect verify-safe <run-id> --dir .agent-inspect
-npx agent-inspect bundle verify .agent-inspect/bundles/<run-id>
+npx agent-inspect bundle <run-id> --dir .agent-inspect --profile share --out ./evidence
+npx agent-inspect bundle verify ./evidence
 ```
 
-Attach the share-profile bundle (or a redacted file) to a PR or issue — not raw traces.
+`--out ./evidence` writes the Evidence v2 package to a known path; `bundle verify ./evidence` checks that exact directory. Do not use `--allow-unsafe` to force a share.
 
-Optional file redaction:
+Optional file redaction before bundling:
 
 ```bash
 npx agent-inspect redact <run-id> --dir .agent-inspect --profile share -o redacted.jsonl
@@ -75,8 +78,9 @@ npx agent-inspect redact <run-id> --dir .agent-inspect --profile share -o redact
 
 | If you use… | Go to |
 | ----------- | ----- |
-| Broken agent demo (same answer, wrong path) | [broken-agent-debugging starter](../examples/starters/broken-agent-debugging/README.md) (`node prove-same-output-wrong-path.mjs`) |
-| Coding-agent MCP loop | [CODING-AGENT-LOOP.md](./CODING-AGENT-LOOP.md) · [coding-agent-debug-loop](../examples/starters/coding-agent-debug-loop/README.md) |
+| Full install + instrumentation guide | [GETTING-STARTED.md](./GETTING-STARTED.md) (site: [/docs/getting-started/guide](/docs/getting-started/guide)) |
+| Broken agent demo (same answer, wrong path) | [broken-agent-debugging starter](../examples/starters/broken-agent-debugging/README.md) |
+| Coding-agent MCP loop | [CODING-AGENT-LOOP.md](./CODING-AGENT-LOOP.md) |
 | Contracts / CI gates | [TRACE-CONTRACTS.md](./TRACE-CONTRACTS.md) · [SUITES-COHORTS-GATES.md](./SUITES-COHORTS-GATES.md) |
 | AI SDK | [AI SDK adoption](./AI-SDK-ADOPTION.md) |
 | OpenAI Agents | [OpenAI Agents local](./OPENAI-AGENTS-LOCAL.md) |

package/docs/GETTING-STARTED.md

@@ -14,7 +14,7 @@ pnpm add agent-inspect
 
 ### Quick bootstrap (v3.1+)
 
-See also [FIRST-TRACE-IN-5-MINUTES.md](./FIRST-TRACE-IN-5-MINUTES.md).
+Prefer the five-minute path first: [FIRST-TRACE-IN-5-MINUTES.md](./FIRST-TRACE-IN-5-MINUTES.md) (site: [/docs/getting-started](/docs/getting-started)). This page is the longer install and instrumentation guide (site: [/docs/getting-started/guide](/docs/getting-started/guide)).
 
 ```bash
 npx agent-inspect init --yes

package/docs/TRACE-CONTRACTS.md

@@ -12,6 +12,7 @@ Contracts compile to deterministic check rules for common cases:
 - tool required / forbidden / allowed / maxCalls / order (`requiredTools` / `forbiddenTools` aliases)
 - selectable `requiredOrderMode` (`first-occurrence` | `happens-before` | `all-occurrences`)
 - additive `tools.orderRules` with per-rule occurrence modes
+- typed cross-kind `steps.orderRelations` (TOOL ↔ LLM endpoints; additive in 6.31)
 - bounded `tools.arguments` JSON Pointer checks (`exists` | `type` | `equals` | `oneOf`)
 - `controls` declared-versus-enforced invariants
 - `retry` / side-effect safety using explicit attempt identity (additive `retry.operations[]` recovery oracles in 6.27)
@@ -61,6 +62,30 @@ For overlapping first calls, omitted / `first-occurrence` warns while `happens-b
 
 Immediate or positional `all-pairs` matching is not implemented.
 
+## `steps.orderRelations` (shipped — experimental, 6.31)
+
+Typed before/after relations with explicit `kind: "TOOL" | "LLM"` endpoints. Use this when a TOOL must precede an LLM (or vice versa). It does **not** change TOOL-only `tools.requiredOrder` / `orderRules` semantics.
+
+```ts
+defineTraceContract({
+  steps: {
+    orderRelations: [
+      {
+        before: { kind: "TOOL", name: "retrieve_policy" },
+        after: { kind: "LLM", name: "generate_answer" },
+        // mode?: "first-occurrence" | "happens-before" | "all-occurrences"
+        // requireEndpoints?: boolean // default true
+      },
+    ],
+  },
+});
+```
+
+- Default `mode` is `first-occurrence` (same three modes as tool order).
+- Default `requireEndpoints: true` — missing kind+name fails; a same display name under the other kind does **not** satisfy the endpoint.
+- LLM names match finished LLM events after stripping common prefixes (`llm:`, `generation:`, …).
+- Low-level `createStepOrderingRule` is compositional when `requireEndpoints` is omitted/false.
+
 ### Experimental Vitest / Jest matchers (shipped)
 
 | Package | Export | Matchers |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-inspect",
-  "version": "6.30.0",
+  "version": "6.31.1",
   "license": "MIT",
   "type": "module",
   "description": "Local evidence debugger and trajectory-test toolkit for TypeScript AI agents — execution trees, TraceContract checks, Evidence v2, and read-only MCP",
@@ -234,7 +234,7 @@
     "test:coverage": "vitest run --coverage",
     "size": "size-limit --config size-limit.config.mjs",
     "test:all": "pnpm run typecheck && pnpm run linked-versions:check && pnpm run build && pnpm run test && pnpm run size",
-    "prepublish:checks": "pnpm run typecheck && pnpm run test && pnpm run test:coverage && pnpm run build && pnpm run fixtures:check && pnpm run recipes:check && pnpm run size && pnpm run linked-versions:check && pnpm run repo:health && pnpm run pack:smoke",
+    "prepublish:checks": "pnpm run typecheck && pnpm run build && pnpm run test && pnpm run test:coverage && pnpm run fixtures:check && pnpm run recipes:check && pnpm run size && pnpm run linked-versions:check && pnpm run repo:health && pnpm run pack:smoke",
     "pack:dry-run": "pnpm run build && npm pack --dry-run",
     "pack:smoke": "pnpm run package-licenses:check && pnpm run build && node scripts/package-smoke.mjs && node scripts/packed-openai-agents-e2e.mjs && node scripts/packed-ai-sdk-e2e.mjs && node scripts/packed-mcp-e2e.mjs && node scripts/packed-quickstart-e2e.mjs && node scripts/packed-semantic-loop-e2e.mjs && node scripts/packed-swarm-loop-e2e.mjs && node scripts/evidence-ci-golden-paths.mjs",
     "linked-versions:check": "node scripts/check-linked-versions.mjs",
@@ -262,6 +262,8 @@
     "website:dev": "pnpm --filter @agent-inspect/website dev",
     "website:build": "pnpm --filter @agent-inspect/website build",
     "website:typecheck": "pnpm --filter @agent-inspect/website typecheck",
+    "website:check": "pnpm --filter @agent-inspect/website check",
+    "website:crawl": "pnpm --filter @agent-inspect/website crawl",
     "package-licenses:check": "node scripts/validate-package-licenses.mjs",
     "package-licenses:sync": "node scripts/sync-package-licenses.mjs",
     "demo-version-sync:check": "node scripts/check-demo-version-sync.mjs"

package/packages/cli/dist/{chunk-BDRJENLM.mjs → chunk-SJ6FRNOE.mjs}

@@ -6351,11 +6351,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 {
@@ -6368,6 +6397,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,
@@ -6407,7 +6447,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);
@@ -6750,6 +6790,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) {
@@ -6999,6 +7051,7 @@ function evaluateBody(input, body, options = {}) {
 }
 function defineTraceContract(input) {
   const shapeErrors = [
+    ...validateAllowedStatusesShape(input.run?.allowedStatuses),
     ...validateAlternativesShape(input.alternatives),
     ...validateScopeShape(input.scope),
     ...validateProvenanceShape(input.observations)
@@ -7029,6 +7082,7 @@ function defineTraceContract(input) {
 }
 function evaluateTraceContract(input, contract, options = {}) {
   const shapeErrors = [
+    ...validateAllowedStatusesShape(contract.run?.allowedStatuses),
     ...validateAlternativesShape(contract.alternatives),
     ...validateScopeShape(contract.scope),
     ...validateProvenanceShape(contract.observations)
@@ -7536,6 +7590,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;
 }
@@ -7562,14 +7641,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 isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -8040,18 +8111,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 [];
       }
@@ -8059,32 +8197,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" }
             )
           ];
         }
@@ -8092,11 +8235,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
               }
@@ -8107,7 +8250,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,
               {
@@ -8120,22 +8263,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" }
             )
           ];
         }
@@ -8167,11 +8307,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
               }
@@ -8182,7 +8322,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,
               {
@@ -8200,10 +8340,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
             },
@@ -8215,6 +8358,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 createLlmUsageRule(options) {
   return {
     id: "llm.usage",
@@ -14733,5 +14885,5 @@ function renderGateReport(result, options = {}) {
 }
 
 export { ATTRIBUTION_CONFIDENCES, COHORT_METRIC_IDS, DEFAULT_SUITE_ARTIFACTS_DIR, EVIDENCE_FORMAT_VERSION, EVIDENCE_HTML_FILENAME, EVIDENCE_MANIFEST_FILENAME, Redactor, TraceDirectory, TraceReadError, TreeBuilder, aggregateBundleSafeStatus, aggregateSessionCheckResults, analyzeCohort, applyProfileMetadataCaps, assertBundlePathContained, assertEvidenceRelativePath, buildActivitySummary, buildBundleMetadata, buildBundleSummaryMarkdown, buildEvidenceCausalFailureViewHtml, buildEvidenceCiPackage, buildEvidenceCircuitViewHtml, buildEvidenceContractsViewHtml, buildEvidenceDiffViewHtml, buildEvidenceHtmlShell, buildEvidenceManifest, buildEvidenceOutcomesViewHtml, buildEvidenceProvenanceViewHtml, buildEvidenceSafetyViewHtml, buildEvidenceTimelineViewHtml, buildEvidenceToolsLlmViewHtml, buildEvidenceTreeViewHtml, buildLocalExplanation, buildPlaceholderArtifact, buildRunSummary, buildRunTimeline, buildRunWhatSummary, buildSessionIndex, buildTraceStats, buildZipArchive, bundleFailsOnSafety, bundleRunAssetRelativePath, collectTraceSchemaVersions, compactAttributes, createBaselineRegressionRule, createLlmUsageRule, createMaxStepDurationRule, createObservedOutcomeRule, createRequireCompletedRule, createRunDepthRule, createRunDurationRule, createRunStatusRule, createSafetyOversizedAttributeRule, createSafetyRawContentRule, createSafetyRedactionRule, createSafetySecretPatternRule, createStallDetectionRule, createStructureCycleRule, createStructureOrphanRule, createStructureParallelWidthRule, createStructureRelationshipRule, createToolUsageRule, defaultBundleOutputPath, defaultSuiteConfigTemplate, defineTraceContract, diffRuns, diffTraceEvents, enrichSessionRunRecord, escapeHtml, escapeMarkdown, evaluateTraceContract, extractMetadata, extractOutcomesFromTraceEvents, filterMetasBySessionScope, filterTraces, flattenTree, formatDuration2 as formatDuration, formatStepLabel, formatTimestamp, gateHasThresholds, getIndent, getTraceFilePath, inferEvidenceFileRole, isAgentInspectTrace, isAttributionConfidence, isPersistedInspectEvent, loadSessionRunRecords, loadSuiteConfig, loadTraceMetadataList, manualTraceEventsToComparableRun, nanoid, normalizeBundleOutputPath, openTrace, parseCohortMetricList, parseDuration, parseDurationFilter, parseGateList, parseTraceJsonl, persistedInspectEventsToTraceEvents, projectLogicalEvents, renderActivitySummaryHuman, renderCohortReport, renderErrorLine, renderGateReport, renderObservedOutcomesHtml, renderObservedOutcomesMarkdown, renderRunDiff, renderRunWhat, renderStepLine, renderSuiteReport, renderTimeline, renderTraceStats, resolveBundleRunIds, resolveRedactionProfile, resolveSuiteTemplate, resolveTraceDir, runGate, runSuite, runTraceChecks, safeString, sanitizeBundleRunId, searchTraces, serializeEvidenceManifest, sha256Hex, stableJson, summarizeObservedOutcomes, summarizeSemanticParity, traceEventToPersistedInspectEvent, truncateName, truncateStringForProfile, validateEvent, validateSuiteConfig, verifyEvidenceDirectory, zeroKinds };
-//# sourceMappingURL=chunk-BDRJENLM.mjs.map
-//# sourceMappingURL=chunk-BDRJENLM.mjs.map
+//# sourceMappingURL=chunk-SJ6FRNOE.mjs.map
+//# sourceMappingURL=chunk-SJ6FRNOE.mjs.map