agent-inspect 6.22.0 → 6.23.0

package/packages/core/dist/{chunk-OG3GAWCX.mjs → chunk-VMDCDWBE.mjs}

@@ -1128,6 +1128,133 @@ function resolveTraceContractScope(input, scope) {
   };
 }
 
+// packages/core/src/checks/tool-arguments.ts
+function decodeToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function resolveJsonPointer(document, pointer) {
+  if (pointer === "") {
+    return { found: true, value: document };
+  }
+  if (!pointer.startsWith("/")) {
+    return { found: false };
+  }
+  const tokens = pointer.slice(1).split("/").map(decodeToken);
+  let current = document;
+  for (const token of tokens) {
+    if (current === null || current === void 0) {
+      return { found: false };
+    }
+    if (Array.isArray(current)) {
+      if (!/^(0|[1-9][0-9]*)$/.test(token)) {
+        return { found: false };
+      }
+      const index = Number(token);
+      if (index >= current.length) {
+        return { found: false };
+      }
+      current = current[index];
+      continue;
+    }
+    if (typeof current !== "object") {
+      return { found: false };
+    }
+    const record = current;
+    if (!Object.prototype.hasOwnProperty.call(record, token)) {
+      return { found: false };
+    }
+    current = record[token];
+  }
+  return { found: true, value: current };
+}
+function jsonType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function valuesEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function extractToolArgumentPayload(event) {
+  const attrs2 = event.attributes ?? {};
+  for (const key of ["arguments", "input", "toolArguments"]) {
+    const candidate = attrs2[key];
+    if (candidate !== void 0 && candidate !== null && typeof candidate === "object") {
+      return { present: true, value: candidate };
+    }
+  }
+  if (event.inputSummary !== void 0 && event.inputSummary !== null && typeof event.inputSummary === "object") {
+    return { present: true, value: event.inputSummary };
+  }
+  return { present: false, value: void 0 };
+}
+function evaluateToolArgumentValue(value, check, evidencePresent) {
+  if (!evidencePresent) {
+    return {
+      status: "unavailable",
+      code: "AI_CHECK_TOOL_ARGUMENT_EVIDENCE_UNAVAILABLE",
+      message: `Structured argument evidence unavailable for tool ${check.tool} at ${check.path}.`
+    };
+  }
+  const resolved = resolveJsonPointer(value, check.path);
+  if (check.operator === "exists") {
+    return resolved.found ? { status: "pass" } : {
+      status: "fail",
+      code: "AI_CHECK_TOOL_ARGUMENT_MISSING",
+      message: `Expected path ${check.path} to exist on tool ${check.tool}.`
+    };
+  }
+  if (!resolved.found) {
+    return {
+      status: "unavailable",
+      code: "AI_CHECK_TOOL_ARGUMENT_EVIDENCE_UNAVAILABLE",
+      message: `Path ${check.path} missing for tool ${check.tool}.`
+    };
+  }
+  if (check.operator === "type") {
+    const actual = jsonType(resolved.value);
+    if (check.type === void 0) {
+      return {
+        status: "fail",
+        code: "AI_CHECK_TOOL_ARGUMENT_INVALID_CONFIG",
+        message: "type operator requires check.type"
+      };
+    }
+    return actual === check.type ? { status: "pass" } : {
+      status: "fail",
+      code: "AI_CHECK_TOOL_ARGUMENT_TYPE",
+      message: `Expected type ${check.type} at ${check.path} for tool ${check.tool}; found ${actual}.`
+    };
+  }
+  if (check.operator === "equals") {
+    return valuesEqual(resolved.value, check.expected) ? { status: "pass" } : {
+      status: "fail",
+      code: "AI_CHECK_TOOL_ARGUMENT_EQUALS",
+      message: `Value at ${check.path} for tool ${check.tool} did not equal expected (bounded comparison).`
+    };
+  }
+  if (check.operator === "oneOf") {
+    const options = check.oneOf ?? [];
+    if (options.length === 0) {
+      return {
+        status: "fail",
+        code: "AI_CHECK_TOOL_ARGUMENT_INVALID_CONFIG",
+        message: "oneOf operator requires a non-empty oneOf array"
+      };
+    }
+    return options.some((option) => valuesEqual(resolved.value, option)) ? { status: "pass" } : {
+      status: "fail",
+      code: "AI_CHECK_TOOL_ARGUMENT_ONE_OF",
+      message: `Value at ${check.path} for tool ${check.tool} was not in the allowed oneOf set.`
+    };
+  }
+  return {
+    status: "fail",
+    code: "AI_CHECK_TOOL_ARGUMENT_INVALID_CONFIG",
+    message: `Unsupported operator.`
+  };
+}
+
 // packages/core/src/safety/sensitive-key.ts
 function keyHasExplicitSeparator(value) {
   return /[_\-.]/.test(value);
@@ -3166,6 +3293,338 @@ function runTraceChecks(input, options = {}) {
   };
 }
 
+// packages/core/src/checks/control-rules.ts
+function asStringList(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== "string" || item.trim() === "") return void 0;
+    out.push(item.trim());
+  }
+  return out;
+}
+function attributeList(events, attribute) {
+  if (!attribute) return void 0;
+  for (const event of events) {
+    const attrs2 = event.attributes;
+    if (!attrs2 || typeof attrs2 !== "object") continue;
+    const direct = asStringList(attrs2[attribute]);
+    if (direct) return direct;
+    const nested = attrs2.metadata && typeof attrs2.metadata === "object" ? asStringList(attrs2.metadata[attribute]) : void 0;
+    if (nested) return nested;
+  }
+  return void 0;
+}
+function fail(ruleId, message, evidence, expected, actual) {
+  return {
+    ruleId,
+    severity: "error",
+    status: "fail",
+    message,
+    ...expected !== void 0 ? { expected } : {},
+    ...actual !== void 0 ? { actual } : {},
+    evidence: [...evidence]
+  };
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+function setEqual(left, right) {
+  const a = sortedUnique(left);
+  const b = sortedUnique(right);
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function evaluateControlRules(events, rules, runEvidence2, observationNames) {
+  const findings = [];
+  const declared = rules.declaredTools ?? attributeList(events, rules.declaredToolsAttribute);
+  const enforced = rules.enforcedTools ?? attributeList(events, rules.enforcedToolsAttribute);
+  if (rules.requireDeclaredMatchesEnforced) {
+    if (declared === void 0 || enforced === void 0) {
+      findings.push(
+        fail(
+          "contract.controls.declared-matches-enforced",
+          "Declared and enforced tool sets could not both be resolved.",
+          runEvidence2,
+          { declaredDefined: declared !== void 0, enforcedDefined: enforced !== void 0 },
+          { code: "AI_CHECK_CONTROL_EVIDENCE_UNAVAILABLE" }
+        )
+      );
+    } else if (!setEqual(declared, enforced)) {
+      findings.push(
+        fail(
+          "contract.controls.declared-matches-enforced",
+          "Declared tools differ from enforced tools.",
+          runEvidence2,
+          sortedUnique(declared),
+          sortedUnique(enforced)
+        )
+      );
+    }
+  }
+  const observedTools = sortedUnique(
+    events.filter((event) => event.kind === "TOOL" && event.status !== "running").map((event) => resolveCanonicalToolName(event))
+  );
+  if (rules.requireObservedWithinEnforced) {
+    if (enforced === void 0) {
+      findings.push(
+        fail(
+          "contract.controls.observed-within-enforced",
+          "Enforced tool set unavailable for observed-within-enforced check.",
+          runEvidence2,
+          void 0,
+          { code: "AI_CHECK_CONTROL_EVIDENCE_UNAVAILABLE" }
+        )
+      );
+    } else {
+      const enforcedSet = new Set(enforced);
+      const outside = observedTools.filter((name) => !enforcedSet.has(name));
+      if (outside.length > 0) {
+        findings.push(
+          fail(
+            "contract.controls.observed-within-enforced",
+            `Observed tools outside enforced allowlist: ${outside.join(", ")}.`,
+            runEvidence2,
+            sortedUnique(enforced),
+            outside
+          )
+        );
+      }
+    }
+  }
+  if (rules.requireObservedWithinDeclared) {
+    if (declared === void 0) {
+      findings.push(
+        fail(
+          "contract.controls.observed-within-declared",
+          "Declared tool set unavailable for observed-within-declared check.",
+          runEvidence2,
+          void 0,
+          { code: "AI_CHECK_CONTROL_EVIDENCE_UNAVAILABLE" }
+        )
+      );
+    } else {
+      const declaredSet = new Set(declared);
+      const outside = observedTools.filter((name) => !declaredSet.has(name));
+      if (outside.length > 0) {
+        findings.push(
+          fail(
+            "contract.controls.observed-within-declared",
+            `Observed tools outside declared set: ${outside.join(", ")}.`,
+            runEvidence2,
+            sortedUnique(declared),
+            outside
+          )
+        );
+      }
+    }
+  }
+  for (const stage of rules.requiredStages ?? []) {
+    const observation = stage.observation ?? `control.${stage.stage}`;
+    if (!observationNames.has(observation)) {
+      findings.push(
+        fail(
+          `contract.controls.stage.${stage.stage}`,
+          `Required control stage observation missing: ${observation}.`,
+          runEvidence2,
+          observation,
+          [...observationNames]
+        )
+      );
+    }
+  }
+  return findings;
+}
+
+// packages/core/src/checks/retry-safety.ts
+function fail2(ruleId, message, evidence, expected, actual) {
+  return {
+    ruleId,
+    severity: "error",
+    status: "fail",
+    message,
+    ...expected !== void 0 ? { expected } : {},
+    ...actual !== void 0 ? { actual } : {},
+    evidence: [...evidence]
+  };
+}
+function workflowFor(event) {
+  const attrs2 = event.attributes;
+  if (!attrs2 || typeof attrs2 !== "object") return {};
+  const direct = extractSessionWorkflowMetadata(attrs2);
+  const nested = attrs2.metadata && typeof attrs2.metadata === "object" ? extractSessionWorkflowMetadata(attrs2.metadata) : void 0;
+  return { ...nested, ...direct };
+}
+function hasIdempotencyEvidence(event) {
+  const workflow = workflowFor(event);
+  if (typeof workflow.idempotencyKey === "string" && workflow.idempotencyKey.trim() !== "") {
+    return true;
+  }
+  const attrs2 = event.attributes ?? {};
+  if (attrs2.noSideEffect === true) return true;
+  if (attrs2.sideEffect === false) return true;
+  return false;
+}
+function eventEvidence2(event) {
+  return {
+    runId: event.runId,
+    eventId: event.eventId,
+    kind: event.kind,
+    name: event.name,
+    status: event.status
+  };
+}
+function evaluateRetrySafetyRules(events, rules, _runEvidence) {
+  const findings = [];
+  const byOperation = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const workflow = workflowFor(event);
+    const operationId = workflow.operationId;
+    if (!operationId) continue;
+    const list = byOperation.get(operationId) ?? [];
+    list.push(event);
+    byOperation.set(operationId, list);
+  }
+  if (rules.maxAttempts !== void 0) {
+    for (const [operationId, members] of byOperation) {
+      const attemptIds = new Set(
+        members.map((event) => workflowFor(event).attemptId).filter((value) => typeof value === "string" && value.trim() !== "")
+      );
+      const attemptNumbers = members.map((event) => workflowFor(event).attemptNumber ?? workflowFor(event).attempt).filter((value) => typeof value === "number" && Number.isFinite(value));
+      const count = attemptIds.size > 0 ? attemptIds.size : attemptNumbers.length > 0 ? Math.max(...attemptNumbers) : members.filter((event) => event.kind === "TOOL" || event.kind === "LLM").length;
+      if (count > rules.maxAttempts) {
+        findings.push(
+          fail2(
+            "contract.retry.max-attempts",
+            `Operation ${operationId} exceeded maxAttempts ${rules.maxAttempts}.`,
+            members.slice(0, 4).map(eventEvidence2),
+            rules.maxAttempts,
+            count
+          )
+        );
+      }
+    }
+  }
+  if (rules.requireTerminalResult) {
+    for (const [operationId, members] of byOperation) {
+      const hasTerminal = members.some((event) => event.status === "ok" || event.status === "error");
+      if (!hasTerminal) {
+        findings.push(
+          fail2(
+            "contract.retry.terminal-result",
+            `Operation ${operationId} has no terminal ok/error result.`,
+            members.slice(0, 4).map(eventEvidence2),
+            "ok|error",
+            members.map((event) => event.status)
+          )
+        );
+      }
+    }
+  }
+  if (rules.fallbackOnlyAfterFailure) {
+    for (const event of events) {
+      const workflow = workflowFor(event);
+      const fallbackOf = workflow.fallbackOf;
+      if (!fallbackOf) continue;
+      const prior = byOperation.get(fallbackOf) ?? events.filter((candidate) => {
+        const meta = workflowFor(candidate);
+        return meta.operationId === fallbackOf || candidate.runId === fallbackOf;
+      });
+      const priorFailure = prior.some((candidate) => candidate.status === "error");
+      if (!priorFailure) {
+        findings.push(
+          fail2(
+            "contract.retry.fallback-after-failure",
+            `Fallback for ${fallbackOf} appeared without a prior failure.`,
+            [eventEvidence2(event)],
+            "prior error attempt",
+            { fallbackOf }
+          )
+        );
+      }
+    }
+  }
+  const nonIdempotent = new Set(rules.nonIdempotentTools ?? []);
+  if (nonIdempotent.size > 0 || rules.requireIdempotencyEvidenceForRetry) {
+    const toolEvents = events.filter(
+      (event) => event.kind === "TOOL" && event.status !== "running"
+    );
+    const byToolOp = /* @__PURE__ */ new Map();
+    for (const event of toolEvents) {
+      const name = resolveCanonicalToolName(event);
+      const workflow = workflowFor(event);
+      const key = `${workflow.operationId ?? name}::${name}`;
+      const list = byToolOp.get(key) ?? [];
+      list.push(event);
+      byToolOp.set(key, list);
+    }
+    for (const [, members] of byToolOp) {
+      const ordered = [...members].sort((a, b) => {
+        const aTime = a.startedAt ?? a.timestamp ?? "";
+        const bTime = b.startedAt ?? b.timestamp ?? "";
+        return aTime.localeCompare(bTime);
+      });
+      let sawOk = false;
+      let sawSideEffectOk = false;
+      for (const event of ordered) {
+        const name = resolveCanonicalToolName(event);
+        const isRetry = sawOk;
+        if (isRetry) {
+          if (rules.requireIdempotencyEvidenceForRetry && !hasIdempotencyEvidence(event)) {
+            findings.push(
+              fail2(
+                "contract.retry.idempotency-evidence",
+                `Retry of tool ${name} lacks idempotencyKey / noSideEffect evidence.`,
+                [eventEvidence2(event)],
+                "idempotencyKey|noSideEffect",
+                { code: "AI_CHECK_RETRY_EVIDENCE_UNAVAILABLE" }
+              )
+            );
+          }
+          if (nonIdempotent.has(name) && sawSideEffectOk && !hasIdempotencyEvidence(event)) {
+            findings.push(
+              fail2(
+                "contract.retry.non-idempotent-side-effect",
+                `Retry of non-idempotent tool ${name} after a confirmed ok side effect.`,
+                [eventEvidence2(event)],
+                "no retry after side effect",
+                name
+              )
+            );
+          }
+        }
+        if (event.status === "ok") {
+          sawOk = true;
+          if (nonIdempotent.has(name) && !hasIdempotencyEvidence(event)) {
+            sawSideEffectOk = true;
+          }
+        }
+      }
+    }
+  }
+  if (rules.requireRecoveredFailureVisible) {
+    for (const [operationId, members] of byOperation) {
+      const hasOk = members.some((event) => event.status === "ok");
+      const hasError = members.some((event) => event.status === "error");
+      const attemptish = members.some((event) => {
+        const meta = workflowFor(event);
+        return meta.attemptId !== void 0 || meta.attemptNumber !== void 0 || meta.attempt !== void 0;
+      }) || members.length > 1;
+      if (hasOk && attemptish && !hasError) {
+        findings.push(
+          fail2(
+            "contract.retry.recovered-failure-visible",
+            `Operation ${operationId} recovered without retaining a visible failure attempt.`,
+            members.slice(0, 4).map(eventEvidence2),
+            "error attempt retained",
+            { hasOk, hasError }
+          )
+        );
+      }
+    }
+  }
+  return findings;
+}
+
 // packages/core/src/checks/contract.ts
 function contractFailFinding(ruleId, message, evidence, expected, actual) {
   return {
@@ -3187,18 +3646,38 @@ function normalizeStatus(status) {
 function cloneBody(body) {
   return {
     ...body.run ? { run: { ...body.run } } : {},
-    ...body.tools ? { tools: { ...body.tools } } : {},
+    ...body.tools ? {
+      tools: {
+        ...body.tools,
+        ...body.tools.arguments ? { arguments: body.tools.arguments.map((item) => ({ ...item })) } : {},
+        ...body.tools.orderRules ? { orderRules: body.tools.orderRules.map((item) => ({ ...item })) } : {}
+      }
+    } : {},
     ...body.llm ? { llm: { ...body.llm } } : {},
     ...body.observations ? {
       observations: {
         ...body.observations,
         ...body.observations.requireProvenance ? { requireProvenance: { ...body.observations.requireProvenance } } : {}
       }
+    } : {},
+    ...body.controls ? {
+      controls: {
+        ...body.controls,
+        ...body.controls.declaredTools ? { declaredTools: [...body.controls.declaredTools] } : {},
+        ...body.controls.enforcedTools ? { enforcedTools: [...body.controls.enforcedTools] } : {},
+        ...body.controls.requiredStages ? { requiredStages: body.controls.requiredStages.map((item) => ({ ...item })) } : {}
+      }
+    } : {},
+    ...body.retry ? {
+      retry: {
+        ...body.retry,
+        ...body.retry.nonIdempotentTools ? { nonIdempotentTools: [...body.retry.nonIdempotentTools] } : {}
+      }
     } : {}
   };
 }
 function bodyHasRules(body) {
-  return body.run !== void 0 || body.tools !== void 0 || body.llm !== void 0 || body.observations !== void 0;
+  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;
 }
 var MAX_EVIDENCE_EVENT_IDS = 16;
 var METHOD_VOCABULARY = new Set(OBSERVED_OUTCOME_METHODS);
@@ -3399,11 +3878,14 @@ function contractToRules(contract) {
   if (contract.tools) {
     const order = contract.tools.requiredOrder ?? [];
     const requiredOrderMode = contract.tools.requiredOrderMode ?? "first-occurrence";
+    const orderRules = contract.tools.orderRules ?? [];
+    const endpointRequired = orderRules.filter((rule) => rule.requireEndpoints !== false).flatMap((rule) => [rule.before, rule.after]);
     const required = [
       .../* @__PURE__ */ new Set([
         ...contract.tools.required ?? [],
         ...contract.tools.requiredTools ?? [],
-        ...order
+        ...order,
+        ...endpointRequired
       ])
     ];
     const forbidden = [
@@ -3428,6 +3910,106 @@ function contractToRules(contract) {
         })
       );
     }
+    const defaultOccurrenceMode = contract.tools.defaultOccurrenceMode ?? requiredOrderMode;
+    for (const [index, rule] of orderRules.entries()) {
+      rules.push(
+        createToolOrderingRule({
+          before: rule.before,
+          after: rule.after,
+          id: `contract.tool.orderRule.${index}`,
+          mode: rule.occurrenceMode ?? defaultOccurrenceMode
+        })
+      );
+    }
+    const argumentChecks = contract.tools.arguments ?? [];
+    if (argumentChecks.length > 0) {
+      rules.push({
+        id: "contract.tool.arguments",
+        category: "tool",
+        defaultSeverity: "error",
+        evaluate(context) {
+          const tools = (context.logicalEvents ?? context.events).filter(
+            (event) => event.kind === "TOOL" && event.status !== "running"
+          );
+          const findings = [];
+          for (const [index, check] of argumentChecks.entries()) {
+            const matches = tools.filter(
+              (event) => resolveCanonicalToolName(event) === check.tool
+            );
+            if (matches.length === 0) {
+              findings.push(
+                contractFailFinding(
+                  `contract.tool.arguments.${index}`,
+                  `No finished tool named ${check.tool} for argument check.`,
+                  context.selectedRun ? [
+                    {
+                      runId: context.selectedRun.runId,
+                      kind: "RUN",
+                      name: context.selectedRun.name
+                    }
+                  ] : [],
+                  { tool: check.tool, path: check.path },
+                  { toolCount: 0 }
+                )
+              );
+              continue;
+            }
+            const occurrence = check.occurrence ?? "all";
+            const selected = occurrence === "first" ? [matches[0]] : occurrence === "last" ? [matches[matches.length - 1]] : matches;
+            const results = selected.map((event) => {
+              const payload = extractToolArgumentPayload(event);
+              return evaluateToolArgumentValue(
+                payload.value,
+                check,
+                payload.present
+              );
+            });
+            if (occurrence === "any") {
+              if (results.some((result) => result.status === "pass")) continue;
+              const firstFail = results.find((result) => result.status !== "pass");
+              findings.push(
+                contractFailFinding(
+                  `contract.tool.arguments.${index}`,
+                  firstFail.message,
+                  selected.slice(0, 1).map((event) => ({
+                    runId: event.runId,
+                    eventId: event.eventId,
+                    kind: event.kind,
+                    name: event.name,
+                    path: `tool.${check.tool}${check.path}`
+                  })),
+                  { tool: check.tool, path: check.path, operator: check.operator },
+                  { code: firstFail.code }
+                )
+              );
+              continue;
+            }
+            for (const [selIndex, result] of results.entries()) {
+              if (result.status === "pass") continue;
+              const event = selected[selIndex];
+              findings.push(
+                contractFailFinding(
+                  `contract.tool.arguments.${index}`,
+                  result.message,
+                  [
+                    {
+                      runId: event.runId,
+                      eventId: event.eventId,
+                      kind: event.kind,
+                      name: event.name,
+                      path: `tool.${check.tool}${check.path}`
+                    }
+                  ],
+                  { tool: check.tool, path: check.path, operator: check.operator },
+                  { code: result.code }
+                )
+              );
+            }
+          }
+          return findings;
+        }
+      });
+    }
   }
   if (contract.llm) {
     rules.push(
@@ -3488,6 +4070,46 @@ function contractToRules(contract) {
       });
     }
   }
+  if (contract.controls) {
+    const controls = contract.controls;
+    rules.push({
+      id: "contract.controls",
+      category: "run",
+      defaultSeverity: "error",
+      evaluate(context) {
+        const events = context.logicalEvents ?? context.events;
+        const outcomes = extractOutcomesFromPersistedEvents(context.events);
+        const observationNames = new Set(outcomes.map((item) => item.name));
+        const runEvidence2 = context.selectedRun ? [
+          {
+            runId: context.selectedRun.runId,
+            kind: "RUN",
+            name: context.selectedRun.name
+          }
+        ] : [];
+        return evaluateControlRules(events, controls, runEvidence2, observationNames);
+      }
+    });
+  }
+  if (contract.retry) {
+    const retry = contract.retry;
+    rules.push({
+      id: "contract.retry",
+      category: "run",
+      defaultSeverity: "error",
+      evaluate(context) {
+        const events = context.logicalEvents ?? context.events;
+        context.selectedRun ? [
+          {
+            runId: context.selectedRun.runId,
+            kind: "RUN",
+            name: context.selectedRun.name
+          }
+        ] : [];
+        return evaluateRetrySafetyRules(events, retry);
+      }
+    });
+  }
   return rules;
 }
 function validateScopeShape(scope) {
@@ -3574,7 +4196,7 @@ function validateAlternativesShape(alternatives) {
       diagnostics.push({
         code: "contract.alternatives.empty-branch",
         severity: "error",
-        message: `Branch ${branch.id} must declare at least one run/tools/llm/observations rule.`,
+        message: `Branch ${branch.id} must declare at least one run/tools/llm/observations/controls/retry rule.`,
         path: `${path}.contract`
       });
     }
@@ -3847,6 +4469,40 @@ function lintTraceContract(contract) {
       path: "tools.requiredOrderMode"
     });
   }
+  const orderRules = contract.tools?.orderRules ?? [];
+  const seenPairs = /* @__PURE__ */ new Set();
+  for (const [index, rule] of orderRules.entries()) {
+    const key = `${rule.before}\0${rule.after}`;
+    if (seenPairs.has(key)) {
+      diagnostics.push({
+        code: "contract.tools.orderRules.duplicate",
+        severity: "warning",
+        message: `Duplicate orderRules pair ${rule.before} \u2192 ${rule.after}.`,
+        path: `tools.orderRules[${index}]`
+      });
+    }
+    seenPairs.add(key);
+    if (rule.before === rule.after) {
+      diagnostics.push({
+        code: "contract.tools.orderRules.self",
+        severity: "error",
+        message: "orderRules before and after must differ.",
+        path: `tools.orderRules[${index}]`
+      });
+    }
+  }
+  if ((contract.tools?.arguments?.length ?? 0) > 0) {
+    for (const [index, check] of (contract.tools?.arguments ?? []).entries()) {
+      if (!check.path.startsWith("/") && check.path !== "") {
+        diagnostics.push({
+          code: "contract.tools.arguments.path",
+          severity: "error",
+          message: 'tools.arguments path must be a JSON Pointer ("" or start with "/").',
+          path: `tools.arguments[${index}].path`
+        });
+      }
+    }
+  }
   return diagnostics;
 }
 function explainTraceContract(contract) {
@@ -3890,6 +4546,17 @@ function explainTraceContract(contract) {
         `Base: requiredOrder [${contract.tools.requiredOrder.join(" \u2192 ")}] mode=${mode}.`
       );
     }
+    if ((contract.tools.orderRules?.length ?? 0) > 0) {
+      const defaultMode = contract.tools.defaultOccurrenceMode ?? "first-occurrence";
+      lines.push(
+        `Base: ${contract.tools.orderRules.length} orderRules (defaultOccurrenceMode=${defaultMode}).`
+      );
+    }
+    if ((contract.tools.arguments?.length ?? 0) > 0) {
+      lines.push(
+        `Base: ${contract.tools.arguments.length} structured tool-argument check(s).`
+      );
+    }
   }
   if (contract.llm) {
     if (contract.llm.maxCalls !== void 0) {
@@ -3920,6 +4587,12 @@ function explainTraceContract(contract) {
       );
     }
   }
+  if (contract.controls) {
+    lines.push("Base: declared-versus-enforced control checks enabled.");
+  }
+  if (contract.retry) {
+    lines.push("Base: retry/side-effect safety checks enabled.");
+  }
   const branches = contract.alternatives?.anyOf ?? [];
   if (branches.length > 0) {
     lines.push(
@@ -3936,6 +4609,6 @@ function explainTraceContract(contract) {
   return lines;
 }
 
-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, evaluateTraceContract, evaluateTraceContractRead, explainTraceContract, extractSessionWorkflowMetadata, lintTraceContract, projectLogicalEvents, resolveCanonicalToolName, resolveTraceContractScope, runTraceChecks, sessionKeyForRun, summarizeSemanticParity, workflowMetadataForRun };
-//# sourceMappingURL=chunk-OG3GAWCX.mjs.map
-//# sourceMappingURL=chunk-OG3GAWCX.mjs.map
+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-VMDCDWBE.mjs.map
+//# sourceMappingURL=chunk-VMDCDWBE.mjs.map