agent-inspect 6.12.0 → 6.12.2

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

@@ -7,7 +7,7 @@ import { P as PersistedInspectEvent } from './persisted-inspect-event-d-mSP8kd.c
 import { Stats } from 'node:fs';
 import { b as ObservedOutcome } from './types-B562HgN_.cjs';
 export { O as ObservedOutcomeStatus } from './types-B562HgN_.cjs';
-import { a as TraceCheckResult, H as TraceCheckStatus } from './index-mdFcxSOR.cjs';
+import { a as TraceCheckResult, J as TraceCheckStatus } from './index-BOP33T4O.cjs';
 import './writers.cjs';
 import './log-config-BG1WmWf2.cjs';
 import './readers.cjs';

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

@@ -7,7 +7,7 @@ import { P as PersistedInspectEvent } from './persisted-inspect-event-ChE7pGb7.j
 import { Stats } from 'node:fs';
 import { b as ObservedOutcome } from './types-B562HgN_.js';
 export { O as ObservedOutcomeStatus } from './types-B562HgN_.js';
-import { a as TraceCheckResult, H as TraceCheckStatus } from './index-BO7l0iAe.js';
+import { a as TraceCheckResult, J as TraceCheckStatus } from './index-CgCH8NE9.js';
 import './writers.js';
 import './log-config-Ck0aT_Ou.js';
 import './readers.js';

package/packages/core/dist/advanced.mjs

@@ -1,4 +1,4 @@
-import { runTraceChecks, createRunStatusRule, createToolUsageRule, createRunDurationRule, createLlmUsageRule, createObservedOutcomeRule } from './chunk-QT6CQ2XA.mjs';
+import { runTraceChecks, createRunStatusRule, createToolUsageRule, createRunDurationRule, createLlmUsageRule, createObservedOutcomeRule } from './chunk-KJICERSD.mjs';
 export { MAX_TERMINAL_DEPTH, MAX_TERMINAL_NAME_LENGTH, TERMINAL_INDENT, TraceDirectory, createInspector, createInspectorRuntime, formatTerminalName, getCurrentContext, getCurrentCorrelationMetadata, getCurrentDepth, getCurrentRunId, getCurrentRunName, getCurrentStepId, getIndent, getParentStepId, getTraceDirFromContext, getTraceSafetyFromContext, hasActiveContext, isAgentInspectEnabled, isSilentContext, maybeInspectRun, printError, printFailedAt, printRunComplete, printRunStart, printStepComplete, printStepStart, renderErrorLine, renderRunSummary, renderStepLine, resolveTraceDir, runWithContext, runWithStepContext } from './chunk-ZWA5RWMV.mjs';
 import { buildRunTimeline, filterTraces, extractMetadata, buildRunSummary } from './chunk-LFWZEO2L.mjs';
 export { buildRunSummary, buildRunTimeline, buildRunWhatSummary, buildTraceStats, extractMetadata, filterTraces, renderRunWhat, renderTimeline, renderTraceStats } from './chunk-LFWZEO2L.mjs';

package/packages/core/dist/checks.cjs

@@ -64,6 +64,260 @@ function outcomesMatchingStatus(outcomes, statuses) {
   return outcomes.filter((outcome) => set.has(outcome.status));
 }
 
+// packages/core/src/checks/logical-events.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function legacyEvent(event) {
+  const value = event.attributes?.legacyEvent;
+  return typeof value === "string" ? value : void 0;
+}
+function stepIdOf(event) {
+  const value = event.attributes?.stepId;
+  if (typeof value === "string" && value.trim() !== "") return value;
+  return void 0;
+}
+function cloneEvent(event) {
+  return {
+    ...event,
+    ...event.attributes !== void 0 ? { attributes: { ...event.attributes } } : {},
+    ...event.error !== void 0 ? { error: { ...event.error } } : {},
+    ...event.tokenUsage !== void 0 ? { tokenUsage: { ...event.tokenUsage } } : {},
+    ...event.source !== void 0 ? { source: { ...event.source } } : {}
+  };
+}
+function mergeAttributes(start, complete) {
+  const merged = {
+    ...isRecord(complete.attributes) ? complete.attributes : {},
+    ...isRecord(start.attributes) ? start.attributes : {}
+  };
+  merged.legacyEvent = start.attributes?.legacyEvent ?? complete.attributes?.legacyEvent;
+  merged.legacyCompleteEvent = complete.attributes?.legacyEvent;
+  if (complete.attributes?.errorStack !== void 0) {
+    merged.errorStack = complete.attributes.errorStack;
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function pairStartComplete(start, complete) {
+  const attributes = mergeAttributes(start, complete);
+  const paired = {
+    ...cloneEvent(start),
+    status: complete.status,
+    timestamp: complete.timestamp ?? start.timestamp,
+    ...complete.endedAt !== void 0 ? { endedAt: complete.endedAt } : {},
+    ...complete.durationMs !== void 0 ? { durationMs: complete.durationMs } : {},
+    ...complete.error !== void 0 ? { error: { ...complete.error } } : {},
+    ...complete.tokenUsage !== void 0 && start.tokenUsage === void 0 ? { tokenUsage: { ...complete.tokenUsage } } : {},
+    ...attributes !== void 0 ? { attributes } : {}
+  };
+  return {
+    ...paired,
+    sourceEventIds: Object.freeze([start.eventId, complete.eventId]),
+    projection: {
+      paired: true,
+      absorbedEventIds: Object.freeze([complete.eventId]),
+      parentNormalized: false,
+      ...start.parentId !== void 0 ? { originalParentId: start.parentId } : {}
+    }
+  };
+}
+function asLogical(event, extras) {
+  return {
+    ...cloneEvent(event),
+    sourceEventIds: Object.freeze([event.eventId]),
+    projection: {
+      paired: false,
+      absorbedEventIds: Object.freeze([]),
+      parentNormalized: extras?.parentNormalized === true,
+      ...{}
+    }
+  };
+}
+function projectLogicalEvents(events) {
+  const diagnostics = [];
+  const byRun = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const list = byRun.get(event.runId) ?? [];
+    list.push(event);
+    byRun.set(event.runId, list);
+  }
+  const absorbedIds = /* @__PURE__ */ new Set();
+  const logicalByRawId = /* @__PURE__ */ new Map();
+  const stepIdToLogicalId = /* @__PURE__ */ new Map();
+  const logical = [];
+  const orderedRuns = [...byRun.keys()].sort((a, b) => a.localeCompare(b));
+  for (const runId of orderedRuns) {
+    const runEvents = byRun.get(runId) ?? [];
+    const starts = [];
+    const completes = [];
+    const others = [];
+    for (const event of runEvents) {
+      const legacy = legacyEvent(event);
+      if (legacy === "step_started" || legacy === "run_started" && event.status === "running") {
+        starts.push(event);
+      } else if (legacy === "step_completed" || legacy === "run_completed") {
+        completes.push(event);
+      } else {
+        others.push(event);
+      }
+    }
+    const usedCompletes = /* @__PURE__ */ new Set();
+    for (const start of starts) {
+      const stepId = stepIdOf(start);
+      let match;
+      if (legacyEvent(start) === "run_started") {
+        const candidates = completes.filter(
+          (c) => !usedCompletes.has(c.eventId) && legacyEvent(c) === "run_completed"
+        );
+        if (candidates.length > 1) {
+          diagnostics.push({
+            code: "AI_LOGICAL_PAIR_AMBIGUOUS",
+            message: `Multiple run_completed rows for run ${runId}; using first by eventId.`,
+            eventIds: candidates.map((c) => c.eventId)
+          });
+          candidates.sort((a, b) => a.eventId.localeCompare(b.eventId));
+        }
+        match = candidates[0];
+      } else if (stepId) {
+        const candidates = completes.filter(
+          (c) => !usedCompletes.has(c.eventId) && legacyEvent(c) === "step_completed" && stepIdOf(c) === stepId
+        );
+        if (candidates.length > 1) {
+          diagnostics.push({
+            code: "AI_LOGICAL_PAIR_AMBIGUOUS",
+            message: `Multiple step_completed rows for stepId ${stepId}; using first by eventId.`,
+            eventIds: candidates.map((c) => c.eventId)
+          });
+          candidates.sort((a, b) => a.eventId.localeCompare(b.eventId));
+        }
+        match = candidates[0];
+      }
+      if (match) {
+        usedCompletes.add(match.eventId);
+        absorbedIds.add(match.eventId);
+        const paired = pairStartComplete(start, match);
+        logical.push(paired);
+        logicalByRawId.set(start.eventId, paired);
+        logicalByRawId.set(match.eventId, paired);
+        if (stepId) stepIdToLogicalId.set(`${runId}:${stepId}`, paired.eventId);
+      } else {
+        diagnostics.push({
+          code: "AI_LOGICAL_PAIR_UNMATCHED_START",
+          message: `No matching complete for start ${start.eventId}.`,
+          eventIds: [start.eventId]
+        });
+        const alone = asLogical(start);
+        logical.push(alone);
+        logicalByRawId.set(start.eventId, alone);
+        if (stepId) stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      }
+    }
+    for (const complete of completes) {
+      if (usedCompletes.has(complete.eventId)) continue;
+      diagnostics.push({
+        code: "AI_LOGICAL_PAIR_UNMATCHED_COMPLETE",
+        message: `No matching start for complete ${complete.eventId}.`,
+        eventIds: [complete.eventId]
+      });
+      const alone = asLogical(complete);
+      logical.push(alone);
+      logicalByRawId.set(complete.eventId, alone);
+      const stepId = stepIdOf(complete);
+      if (stepId && !stepIdToLogicalId.has(`${runId}:${stepId}`)) {
+        stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      }
+    }
+    for (const event of others) {
+      const alone = asLogical(event);
+      logical.push(alone);
+      logicalByRawId.set(event.eventId, alone);
+      const stepId = stepIdOf(event);
+      if (stepId && !stepIdToLogicalId.has(`${runId}:${stepId}`)) {
+        stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      }
+    }
+  }
+  const logicalById = new Map(logical.map((e) => [e.eventId, e]));
+  const normalized = [];
+  for (const event of logical) {
+    const originalParentId = event.parentId;
+    if (!originalParentId) {
+      normalized.push(event);
+      continue;
+    }
+    let nextParent = originalParentId;
+    let remapped = false;
+    const viaAbsorbed = logicalByRawId.get(originalParentId);
+    if (viaAbsorbed && viaAbsorbed.eventId !== originalParentId) {
+      nextParent = viaAbsorbed.eventId;
+      remapped = true;
+    } else if (!logicalById.has(originalParentId)) {
+      const viaStep = stepIdToLogicalId.get(`${event.runId}:${originalParentId}`);
+      if (viaStep) {
+        nextParent = viaStep;
+        remapped = true;
+      }
+    }
+    if (!remapped) {
+      if (!logicalById.has(originalParentId) && !logicalByRawId.has(originalParentId)) {
+        diagnostics.push({
+          code: "AI_LOGICAL_PARENT_UNRESOLVED",
+          message: `Parent ${originalParentId} unresolved for ${event.eventId}.`,
+          eventIds: [event.eventId]
+        });
+      }
+      normalized.push(event);
+      continue;
+    }
+    diagnostics.push({
+      code: "AI_LOGICAL_PARENT_REMAPPED",
+      message: `Remapped parent ${originalParentId} \u2192 ${nextParent} for ${event.eventId}.`,
+      eventIds: [event.eventId]
+    });
+    normalized.push({
+      ...event,
+      parentId: nextParent,
+      projection: {
+        ...event.projection,
+        parentNormalized: true,
+        originalParentId
+      }
+    });
+  }
+  const rawIndex = new Map(events.map((e, i) => [e.eventId, i]));
+  normalized.sort((a, b) => {
+    const ai = rawIndex.get(a.sourceEventIds[0]) ?? 0;
+    const bi = rawIndex.get(b.sourceEventIds[0]) ?? 0;
+    return ai - bi || a.eventId.localeCompare(b.eventId);
+  });
+  return {
+    logicalEvents: Object.freeze(normalized),
+    diagnostics: Object.freeze(diagnostics)
+  };
+}
+function resolveCanonicalToolName(event) {
+  const attrs = event.attributes;
+  const direct = pickString(attrs, ["toolName", "tool"]);
+  if (direct) return direct;
+  const metadata = attrs?.metadata;
+  if (isRecord(metadata)) {
+    const nested = pickString(metadata, ["toolName", "tool"]);
+    if (nested) return nested;
+  }
+  for (const prefix of ["tool:", "function:", "mcp-tools:"]) {
+    if (event.name.startsWith(prefix)) return event.name.slice(prefix.length);
+  }
+  return event.name;
+}
+function pickString(record, keys) {
+  if (!record) return void 0;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
+  }
+  return void 0;
+}
+
 // packages/core/src/checks/contract.ts
 function contractFailFinding(ruleId, message, evidence, expected, actual) {
   return {
@@ -121,7 +375,9 @@ function contractToRules(contract) {
           );
         }
         if (!allowIncomplete) {
-          const running = context.events.filter((event) => event.status === "running");
+          const running = (context.logicalEvents ?? context.events).filter(
+            (event) => event.status === "running"
+          );
           if (running.length > 0) {
             findings.push(
               contractFailFinding(
@@ -285,7 +541,11 @@ var DEFAULT_RAW_CONTENT_KEYS = [
   "conversationtext",
   "conversation_text"
 ];
-var DEFAULT_SAFE_RAW_CONTENT_PATH_PREFIXES = ["tokenUsage", "usage"];
+var DEFAULT_SAFE_RAW_CONTENT_PATH_PREFIXES = [
+  "tokenUsage",
+  "usage",
+  "tokens"
+];
 var SAFE_USAGE_LEAF_KEYS = /* @__PURE__ */ new Set([
   "input",
   "output",
@@ -361,10 +621,13 @@ function buildFacts(input, selectedRun) {
       childrenByParentId.set(parentId, children);
     }
   }
+  const projection = projectLogicalEvents(scopedEvents);
   return {
     format: input.read.format,
     runs: Object.freeze([...input.read.runs]),
     events: Object.freeze([...scopedEvents]),
+    logicalEvents: projection.logicalEvents,
+    logicalProjectionDiagnostics: projection.diagnostics,
     readerWarnings: Object.freeze([...input.read.warnings]),
     unsupportedFields: Object.freeze([...input.read.unsupportedFields]),
     sourceFiles: Object.freeze([...input.read.sourceFiles]),
@@ -557,7 +820,10 @@ function failFinding(ruleId, message, evidence, expected, actual, meta) {
   };
 }
 function toolName(event) {
-  return stringAttr(event, ["toolName", "tool"]) ?? stripPrefix(event.name, ["tool:", "function:", "mcp-tools:"]);
+  return resolveCanonicalToolName(event);
+}
+function semanticEvents(context) {
+  return context.logicalEvents ?? context.events;
 }
 function llmModel(event) {
   return stringAttr(event, ["model", "modelId", "responseModelId", "modelName", "model_name"]) ?? stripPrefix(event.name, ["llm:", "generation:", "transcription:", "speech:"]);
@@ -572,7 +838,7 @@ function retryCount(event) {
   return numericAttr(event, ["retryCount", "retryAttempt", "retry_attempt", "attempt"]);
 }
 function finishedEvents(context, kind) {
-  return context.events.filter(
+  return semanticEvents(context).filter(
     (event) => (kind === void 0 || event.kind === kind) && event.status !== "running"
   );
 }
@@ -584,7 +850,7 @@ function firstIndexByName(events) {
   }
   return index;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function eventMap(events) {
@@ -638,7 +904,7 @@ function pushValueEntries(entries, event, value, path3, key, depth = 0) {
     }
     return;
   }
-  if (!isRecord(value)) return;
+  if (!isRecord2(value)) return;
   for (const nestedKey of Object.keys(value).sort((a, b) => a.localeCompare(b))) {
     pushValueEntries(
       entries,
@@ -718,14 +984,11 @@ function signalName(event, attributeKeys, prefixes) {
   return stringAttr(event, attributeKeys) ?? stripPrefix(event.name, prefixes);
 }
 function guardrailEvents(context) {
-  return finishedEvents2().filter((event) => {
+  return finishedEvents(context).filter((event) => {
     const name = event.name.toLowerCase();
     if (name.startsWith("guardrail:") || name.includes(".guardrail.")) return true;
     return stringAttr(event, ["guardrailName", "guardrail", "guardrailId"]) !== void 0;
   });
-  function finishedEvents2() {
-    return context.events.filter((event) => event.status !== "running");
-  }
 }
 function retryValue(event) {
   return retryCount(event) ?? 0;
@@ -746,7 +1009,7 @@ function treeShape(nodes) {
   return lines;
 }
 function statusShape(context) {
-  return context.events.map((event) => `${event.kind}:${event.name}:${event.status ?? "unknown"}`).sort((a, b) => a.localeCompare(b));
+  return semanticEvents(context).map((event) => `${event.kind}:${event.name}:${event.status ?? "unknown"}`).sort((a, b) => a.localeCompare(b));
 }
 function toolShape(context) {
   return finishedEvents(context, "TOOL").map(
@@ -772,7 +1035,7 @@ function llmShape(context) {
   );
 }
 function errorShape(context) {
-  return context.events.filter((event) => event.status === "error" || event.error !== void 0).map(
+  return semanticEvents(context).filter((event) => event.status === "error" || event.error !== void 0).map(
     (event) => [
       event.kind,
       event.name,
@@ -790,7 +1053,7 @@ function guardrailShape(context) {
   return guardrailEvents(context).map((event) => signalName(event, ["guardrailName", "guardrail", "guardrailId"], ["guardrail:"])).sort((a, b) => a.localeCompare(b));
 }
 function firstEvidenceForKind(context, kind, path3) {
-  const event = context.events.find((candidate) => candidate.kind === kind);
+  const event = semanticEvents(context).find((candidate) => candidate.kind === kind);
   return event ? [eventEvidence(event, path3)] : runEvidence(context.selectedRun);
 }
 function baselineDiffFinding(message, evidence, expected, actual) {
@@ -818,7 +1081,7 @@ function createRunStatusRule(options = {}) {
         );
       }
       if (!allowIncomplete) {
-        const running = context.events.filter((event) => event.status === "running");
+        const running = semanticEvents(context).filter((event) => event.status === "running");
         if (running.length > 0) {
           findings.push(
             failFinding(
@@ -861,7 +1124,7 @@ function createMaxStepDurationRule(options) {
     category: "run",
     defaultSeverity: "error",
     evaluate(context) {
-      const over = context.events.filter((event) => {
+      const over = semanticEvents(context).filter((event) => {
         const duration = eventDurationMs(event);
         return duration !== void 0 && duration > options.maxDurationMs;
       });
@@ -890,7 +1153,7 @@ function createStallDetectionRule(options = {}) {
     defaultSeverity: "warning",
     evaluate(context) {
       const findings = [];
-      const running = context.events.filter((event) => event.status === "running");
+      const running = semanticEvents(context).filter((event) => event.status === "running");
       if (running.length > 0) {
         findings.push(
           failFinding(
@@ -903,7 +1166,7 @@ function createStallDetectionRule(options = {}) {
         );
       }
       if (requireEndedAt) {
-        const incomplete = context.events.filter(
+        const incomplete = semanticEvents(context).filter(
           (event) => event.startedAt !== void 0 && event.endedAt === void 0 && event.status !== "running"
         );
         if (incomplete.length > 0) {
@@ -941,7 +1204,7 @@ function createRequireCompletedRule() {
           )
         );
       }
-      const running = context.events.filter((event) => event.status === "running");
+      const running = semanticEvents(context).filter((event) => event.status === "running");
       if (running.length > 0) {
         findings.push(
           failFinding(
@@ -963,7 +1226,7 @@ function createRunEventCountRule(options) {
     category: "run",
     defaultSeverity: "error",
     evaluate(context) {
-      const count = context.events.filter(
+      const count = semanticEvents(context).filter(
         (event) => options.kind === void 0 || event.kind === options.kind
       ).length;
       const findings = [];
@@ -1214,7 +1477,7 @@ function createStructureIncompleteRule(options = {}) {
     evaluate(context) {
       const findings = [];
       if (!options.allowRunning) {
-        const running = context.events.filter((event) => event.status === "running");
+        const running = semanticEvents(context).filter((event) => event.status === "running");
         if (running.length > 0) {
           findings.push(
             failFinding(
@@ -1228,7 +1491,7 @@ function createStructureIncompleteRule(options = {}) {
         }
       }
       if (options.requireEndedAtForStarted) {
-        const missingEndedAt = context.events.filter(
+        const missingEndedAt = semanticEvents(context).filter(
           (event) => event.startedAt !== void 0 && event.endedAt === void 0 && event.status !== "running"
         );
         if (missingEndedAt.length > 0) {
@@ -1254,8 +1517,8 @@ function createStructureOrphanRule(options = {}) {
     category: "structure",
     defaultSeverity: "error",
     evaluate(context) {
-      const byId = eventMap(context.events);
-      const orphans = context.events.filter((event) => {
+      const byId = eventMap(semanticEvents(context));
+      const orphans = semanticEvents(context).filter((event) => {
         if (!event.parentId || byId.has(event.parentId)) return false;
         return !(allowMarkedUnresolved && parentMarkedUnresolved(event));
       });
@@ -1278,10 +1541,10 @@ function createStructureCycleRule() {
     category: "structure",
     defaultSeverity: "error",
     evaluate(context) {
-      const byId = eventMap(context.events);
+      const byId = eventMap(semanticEvents(context));
       const seenCycles = /* @__PURE__ */ new Set();
       const findings = [];
-      for (const event of [...context.events].sort((a, b) => a.eventId.localeCompare(b.eventId))) {
+      for (const event of [...semanticEvents(context)].sort((a, b) => a.eventId.localeCompare(b.eventId))) {
         const path3 = [];
         const seenAt = /* @__PURE__ */ new Map();
         let current = event;
@@ -1319,10 +1582,10 @@ function createStructureRelationshipRule(options = {}) {
     category: "structure",
     defaultSeverity: "error",
     evaluate(context) {
-      const byId = eventMap(context.events);
+      const byId = eventMap(semanticEvents(context));
       const findings = [];
       const minConfidence = options.minConfidence;
-      for (const event of context.events) {
+      for (const event of semanticEvents(context)) {
         if (minConfidence && CONFIDENCE_RANK[event.confidence] < CONFIDENCE_RANK[minConfidence]) {
           findings.push(
             failFinding(
@@ -1390,7 +1653,7 @@ function createStructureParallelWidthRule(options) {
     defaultSeverity: "error",
     evaluate(context) {
       const findings = [];
-      const byId = eventMap(context.events);
+      const byId = eventMap(semanticEvents(context));
       if (options.maxChildren !== void 0) {
         for (const [parentId, children] of context.childrenByParentId.entries()) {
           if (children.length <= options.maxChildren) continue;
@@ -1417,7 +1680,7 @@ function createStructureParallelWidthRule(options) {
         }
       }
       if (options.maxConcurrent !== void 0) {
-        const intervals = context.events.map((event) => ({ event, start: eventStartMs(event), end: eventEndMs(event) })).filter(
+        const intervals = semanticEvents(context).map((event) => ({ event, start: eventStartMs(event), end: eventEndMs(event) })).filter(
           (item) => item.start !== void 0 && item.end !== void 0 && item.end > item.start
         );
         const points = intervals.flatMap((item) => [
@@ -1713,7 +1976,7 @@ function createSafetyOversizedAttributeRule(options) {
               )
             );
           }
-          if (isRecord(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
+          if (isRecord2(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
             findings.push(
               failFinding(
                 "safety.oversizedAttribute",
@@ -1990,6 +2253,8 @@ exports.createToolOrderingRule = createToolOrderingRule;
 exports.createToolUsageRule = createToolUsageRule;
 exports.defineTraceContract = defineTraceContract;
 exports.evaluateTraceContract = evaluateTraceContract;
+exports.projectLogicalEvents = projectLogicalEvents;
+exports.resolveCanonicalToolName = resolveCanonicalToolName;
 exports.runTraceChecks = runTraceChecks;
 //# sourceMappingURL=checks.cjs.map
 //# sourceMappingURL=checks.cjs.map