agent-inspect 6.31.32 → 6.31.34

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 6.31.34
+
+### Patch Changes
+
+- c0726d8: Detect underscore-adjacent Stripe keys across redact, credential-value, and verify-safe patterns (#528; thanks Frank). Align `gate --evidence-on` check-results `aggregateStatus` with residual artifact assessment while keeping gate pass/fail separate (#529; thanks Frank). Fail unfinished before-order occurrences even when a finished peer exists, and treat after-start without a terminal as order-relevant. Harden Gary/Nest saved verifiers, refuse ambiguous HTML lifecycle joins, and evaluate Roy UNPROVABLE positive controls.
+
+## 6.31.33
+
+### Patch Changes
+
+- b2adf03: Fail requiredOrder when a before tool starts but never finishes while after runs (#521). Escape mixed-script lookalike tool names in tool.usage findings and sort allowlist causes first (#522).
+
 ## 6.31.32
 
 ### Patch Changes

package/README.md

@@ -213,7 +213,7 @@ The root package is enough for custom capture, the CLI, checks, and Evidence wor
 
 ## Status and documentation
 
-**Current published baseline:** **6.31.32** · persisted schema `1.0` · Node.js `>=20` · MIT.
+**Current published baseline:** **6.31.34** · 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/TRACE-CONTRACTS.md

@@ -45,6 +45,7 @@ Contracts compile to deterministic check rules for common cases:
 - `all-occurrences` requires every `before` occurrence to finish before every `after` occurrence starts (`max(before.end) <= min(after.start)`);
 - causal modes fail when a required interval boundary cannot be resolved instead of falling back to encounter order.
 - when the boundary timestamps tie at millisecond resolution (for example scripted or mocked tools that start and finish inside one millisecond), causal modes decide by recorded event order: the before event must have been recorded as finished before the after event was recorded as started. Such findings carry `resolvedBy: "recorded-order"`.
+- a `before` tool that starts but never finishes (`status: "running"`) while a later `after` tool finishes fails the order rule in every mode with `tool.order.interval-unresolved` (unfinished before), naming the abandoned tool — not only the generic incomplete-running `run.status` finding.
 
 Examples for `requiredOrder: ["retrieve_policy", "send_email"]` (both TOOL-typed):
 
@@ -120,6 +121,7 @@ The evaluator expands each list into adjacent pairs and applies one `requiredOrd
 - `requiredOrderMode: "all-occurrences"` requires every before to end before every after starts; any cross-boundary overlap or later before fails.
 - Missing interval boundaries fail closed in the two causal modes.
 - Millisecond timestamp ties are decided by recorded event order in the two causal modes.
+- A started-but-never-finished `before` tool (running, no completion) fails order in every mode when `after` has finished, with `tool.order.interval-unresolved`.
 
 ### `alternatives.anyOf` (shipped)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-inspect",
-  "version": "6.31.32",
+  "version": "6.31.34",
   "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",

package/packages/cli/dist/{chunk-PEGM6T2X.mjs → chunk-6TXW53UR.mjs}

@@ -938,8 +938,9 @@ var HIGH_CONFIDENCE_CREDENTIAL_PATTERNS = [
   /\beyJ[a-zA-Z0-9_-]{8,}\.[a-zA-Z0-9_-]{8,}\.[a-zA-Z0-9_-]{8,}\b/,
   /\b(?:sk-(?:proj-)?[a-zA-Z0-9_-]{16,}|sk-ant-[a-zA-Z0-9_-]{16,}|AIza[0-9A-Za-z_-]{20,})\b/,
   // Stripe secret / restricted keys use underscores (not sk-). Keep in sync with
-  // packages/redact/src/index.ts + packages/core/src/checks DEFAULT_SECRET_PATTERNS (#520).
-  /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b/,
+  // packages/redact/src/index.ts + packages/core/src/checks DEFAULT_SECRET_PATTERNS (#520/#528).
+  // Use non-alnum lookarounds so underscore-adjacent forms (acct_sk_live_…, …_eu) match.
+  /(?<![A-Za-z0-9])(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}(?![A-Za-z0-9])/,
   /\bxox[abposr]-[A-Za-z0-9-]{10,}\b/,
   /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{20,}\b/,
   /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/,
@@ -7051,10 +7052,17 @@ function contractToRules(contract) {
             (event) => event.status === "running"
           );
           if (running.length > 0) {
+            const labels = running.map((event) => {
+              if (event.kind === "TOOL") {
+                return `tool ${resolveCanonicalToolName(event)}`;
+              }
+              return `${event.kind} ${event.name}`;
+            });
+            const message = labels.length === 1 ? `Run contains incomplete running events: ${labels[0]} never completed.` : `Run contains incomplete running events: ${labels.join("; ")}.`;
             findings.push(
               contractFailFinding(
                 "contract.run.allowedStatuses",
-                "Run contains incomplete running events.",
+                message,
                 running.map((event) => ({
                   runId: event.runId,
                   eventId: event.eventId,
@@ -7063,7 +7071,10 @@ function contractToRules(contract) {
                   status: event.status
                 })),
                 "no running events",
-                running.length
+                {
+                  count: running.length,
+                  unfinished: labels
+                }
               )
             );
           }
@@ -7822,10 +7833,11 @@ var SAFE_USAGE_LEAF_KEYS = /* @__PURE__ */ new Set([
 var DEFAULT_SECRET_PATTERNS = [
   { id: "bearer-token", pattern: /Bearer\s+[A-Za-z0-9._~+/-]{12,}=*/ },
   { id: "openai-key", pattern: /sk-[A-Za-z0-9_-]{16,}/ },
-  // Stripe + Slack: keep in sync with packages/redact + credential-value-patterns (#520).
+  // Stripe + Slack: keep in sync with packages/redact + credential-value-patterns (#520/#528).
+  // Non-alnum lookarounds so underscore-adjacent forms (acct_sk_live_…, …_eu) match.
   {
     id: "stripe-key",
-    pattern: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b/
+    pattern: /(?<![A-Za-z0-9])(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}(?![A-Za-z0-9])/
   },
   { id: "slack-token", pattern: /\bxox[abposr]-[A-Za-z0-9-]{10,}\b/ },
   { id: "aws-access-key", pattern: /AKIA[0-9A-Z]{16}/ },
@@ -8009,6 +8021,11 @@ function compareFindings(eventById) {
     if (STATUS_RANK[a.status] !== STATUS_RANK[b.status]) {
       return STATUS_RANK[a.status] - STATUS_RANK[b.status];
     }
+    if (a.ruleId === "tool.usage") {
+      const aHasEvent = a.evidence[0]?.eventId !== void 0;
+      const bHasEvent = b.evidence[0]?.eventId !== void 0;
+      if (aHasEvent !== bHasEvent) return aHasEvent ? -1 : 1;
+    }
     const byRun = compareStrings(a.evidence[0]?.runId, b.evidence[0]?.runId);
     if (byRun !== 0) return byRun;
     const byTime = eventTimestamp(a, eventById).localeCompare(eventTimestamp(b, eventById));
@@ -8134,6 +8151,37 @@ function failFinding(ruleId, message, evidence, expected, actual, meta) {
 function toolName(event) {
   return resolveCanonicalToolName(event);
 }
+function formatToolNameForMessage(name) {
+  const details = [];
+  for (let index = 0; index < name.length; ) {
+    const codePoint = name.codePointAt(index);
+    const width = codePoint > 65535 ? 2 : 1;
+    if (codePoint > 127) {
+      details.push(
+        `U+${codePoint.toString(16).toUpperCase().padStart(4, "0")} at index ${index}`
+      );
+    }
+    index += width;
+  }
+  if (details.length === 0) return name;
+  return `"${name}" (contains ${details.join("; ")})`;
+}
+function describeRunningEvent(event) {
+  if (event.kind === "TOOL") {
+    return `tool ${formatToolNameForMessage(resolveCanonicalToolName(event))}`;
+  }
+  if (event.kind === "LLM") {
+    return `llm ${stepEndpointName(event, "LLM")}`;
+  }
+  return `${event.kind} ${event.name}`;
+}
+function incompleteRunningMessage(prefix, running) {
+  const labels = running.map(describeRunningEvent);
+  if (labels.length === 1) {
+    return `${prefix}: ${labels[0]} never completed.`;
+  }
+  return `${prefix}: ${labels.join("; ")}.`;
+}
 function stepEndpointName(event, kind) {
   if (kind === "TOOL") return resolveCanonicalToolName(event);
   for (const prefix of ["llm:", "generation:", "transcription:", "speech:"]) {
@@ -8475,10 +8523,13 @@ function createRunStatusRule(options = {}) {
           findings.push(
             failFinding(
               "run.status",
-              "Run contains incomplete running events.",
+              incompleteRunningMessage("Run contains incomplete running events", running),
               running.map((event) => eventEvidence3(event)),
               "no running events",
-              running.length
+              {
+                count: running.length,
+                unfinished: running.map(describeRunningEvent)
+              }
             )
           );
         }
@@ -8648,6 +8699,34 @@ function createToolUsageRule(options) {
       const names = tools.map(toolName);
       const nameSet = new Set(names);
       const findings = [];
+      const forbidden = new Set(options.forbidden ?? []);
+      const allowed = options.allowed?.length ? new Set(options.allowed) : void 0;
+      for (const event of tools) {
+        const name = toolName(event);
+        const display = formatToolNameForMessage(name);
+        if (forbidden.has(name)) {
+          findings.push(
+            failFinding(
+              "tool.usage",
+              `Forbidden tool ${display} appeared.`,
+              [eventEvidence3(event)],
+              "tool absent",
+              name
+            )
+          );
+        }
+        if (allowed && !allowed.has(name)) {
+          findings.push(
+            failFinding(
+              "tool.usage",
+              `Tool ${display} is not in the allowed tool set.`,
+              [eventEvidence3(event)],
+              [...allowed].sort(),
+              name
+            )
+          );
+        }
+      }
       for (const required of options.required ?? []) {
         if (!nameSet.has(required)) {
           const otherKinds = [
@@ -8665,7 +8744,7 @@ function createToolUsageRule(options) {
           findings.push(
             failFinding(
               "tool.usage",
-              `Required tool ${required} did not appear.${hint}`,
+              `Required tool ${formatToolNameForMessage(required)} did not appear.${hint}`,
               runEvidence(context.selectedRun),
               required,
               names
@@ -8673,21 +8752,6 @@ function createToolUsageRule(options) {
           );
         }
       }
-      const forbidden = new Set(options.forbidden ?? []);
-      const allowed = options.allowed?.length ? new Set(options.allowed) : void 0;
-      for (const event of tools) {
-        const name = toolName(event);
-        if (forbidden.has(name)) {
-          findings.push(
-            failFinding("tool.usage", `Forbidden tool ${name} appeared.`, [eventEvidence3(event)], "tool absent", name)
-          );
-        }
-        if (allowed && !allowed.has(name)) {
-          findings.push(
-            failFinding("tool.usage", `Tool ${name} is not in the allowed tool set.`, [eventEvidence3(event)], [...allowed].sort(), name)
-          );
-        }
-      }
       if (options.minCount !== void 0 && tools.length < options.minCount) {
         findings.push(
           failFinding("tool.usage", `Tool count ${tools.length} was below minimum ${options.minCount}.`, runEvidence(context.selectedRun), { minCount: options.minCount }, tools.length)
@@ -8721,7 +8785,36 @@ function createStepOrderingRule(options) {
       const afterEvents = finishedEvents(context, options.after.kind).filter(
         (event) => stepEndpointName(event, options.after.kind) === options.after.name
       );
-      if (beforeEvents.length === 0 || afterEvents.length === 0) {
+      const beforeRunning = semanticEvents(context).filter(
+        (event) => event.kind === options.before.kind && event.status === "running" && stepEndpointName(event, options.before.kind) === options.before.name
+      );
+      const afterRunning = semanticEvents(context).filter(
+        (event) => event.kind === options.after.kind && event.status === "running" && stepEndpointName(event, options.after.kind) === options.after.name
+      );
+      const afterStarted = afterEvents.length > 0 || afterRunning.length > 0;
+      const afterEvidenceEvent = afterEvents[0] ?? afterRunning[0];
+      if (beforeRunning.length > 0 && afterStarted && afterEvidenceEvent !== void 0) {
+        const endpointExpected2 = bothTools ? { before: options.before.name, after: options.after.name } : { before: options.before, after: options.after };
+        return [
+          failFinding(
+            ruleId,
+            `${subject} ${beforeLabel} started but never finished before ${afterLabel} ran.`,
+            [
+              ...beforeRunning.map((event) => eventEvidence3(event)),
+              eventEvidence3(afterEvidenceEvent)
+            ],
+            { ...endpointExpected2, mode },
+            {
+              code: bothTools ? "tool.order.interval-unresolved" : "step.order.interval-unresolved",
+              unfinishedBefore: true,
+              beforeStatus: "running",
+              ...beforeEvents.length > 0 ? { finishedBeforeMasked: true } : {},
+              ...afterEvents.length === 0 ? { afterStatus: "running" } : {}
+            }
+          )
+        ];
+      }
+      if (beforeEvents.length === 0 || !afterStarted) {
         if (!requireEndpoints) return [];
         const findings = [];
         if (beforeEvents.length === 0) {
@@ -8745,7 +8838,7 @@ function createStepOrderingRule(options) {
             )
           );
         }
-        if (afterEvents.length === 0) {
+        if (!afterStarted) {
           const otherKinds = otherKindsForStepName(
             context,
             options.after.kind,
@@ -8768,9 +8861,15 @@ function createStepOrderingRule(options) {
         }
         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
-      );
+      const afterForOrder = afterEvents.length > 0 ? afterEvents : afterRunning;
+      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
+        ),
+        ...afterEvents.length === 0 ? afterRunning.filter(
+          (event) => !finishedEvents(context).some((finished) => finished.eventId === event.eventId)
+        ) : []
+      ];
       let beforeIndex;
       let afterIndex;
       for (const [position, event] of encounter.entries()) {
@@ -8801,7 +8900,7 @@ function createStepOrderingRule(options) {
         ];
       }
       const beforeEvent = beforeEvents[0];
-      const afterEvent = afterEvents[0];
+      const afterEvent = afterForOrder[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 };
@@ -8887,7 +8986,7 @@ function createStepOrderingRule(options) {
             latestBefore = { event, end };
           }
         }
-        for (const event of afterEvents) {
+        for (const event of afterForOrder) {
           const start = eventStartMs(event);
           if (start === void 0) {
             missingAfterStarts += 1;
@@ -8916,7 +9015,7 @@ function createStepOrderingRule(options) {
         const tie = tiedEnd === tiedStart ? recordedTieOrder(
           context,
           beforeEvents.filter((event) => eventEndMs(event) === tiedEnd),
-          afterEvents.filter((event) => eventStartMs(event) === tiedStart)
+          afterForOrder.filter((event) => eventStartMs(event) === tiedStart)
         ) : void 0;
         if (latestBefore.end > earliestAfter.start || tie !== void 0 && tie.inOrder !== true) {
           return [
@@ -9097,10 +9196,13 @@ function createStructureIncompleteRule(options = {}) {
           findings.push(
             failFinding(
               "structure.incomplete",
-              "Trace contains incomplete running events.",
+              incompleteRunningMessage("Trace contains incomplete running events", running),
               running.map((event) => eventEvidence3(event, "status")),
               "no running events",
-              running.length
+              {
+                count: running.length,
+                unfinished: running.map(describeRunningEvent)
+              }
             )
           );
         }
@@ -16084,5 +16186,5 @@ function renderGateReport(result, options = {}) {
 }
 
 export { ATTRIBUTION_CONFIDENCES, COHORT_METRIC_IDS, DEFAULT_REDACT_KEYS, DEFAULT_SUITE_ARTIFACTS_DIR, DELIVERY_CONFLICT_ATTR, DELIVERY_EVENT_BASE_ATTR, EVIDENCE_FORMAT_VERSION, EVIDENCE_HTML_FILENAME, EVIDENCE_MANIFEST_FILENAME, IDENTITY_CONFLICT_ATTR, 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, isCredentialSensitiveKey, isPersistedInspectEvent, loadSessionRunRecords, loadSuiteConfig, loadTraceMetadataList, manualTraceEventsToComparableRun, nanoid, normalizeBundleOutputPath, openTrace, parseCohortMetricList, parseDuration, parseDurationFilter, parseGateList, parseTraceJsonl, persistedInspectEventsToRunTrees, 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, stringContainsHighConfidenceCredential, summarizeObservedOutcomes, summarizeSemanticParity, traceEventToPersistedInspectEvent, truncateName, truncateStringForProfile, validateEvent, validateSuiteConfig, verifyEvidenceDirectory, zeroKinds };
-//# sourceMappingURL=chunk-PEGM6T2X.mjs.map
-//# sourceMappingURL=chunk-PEGM6T2X.mjs.map
+//# sourceMappingURL=chunk-6TXW53UR.mjs.map
+//# sourceMappingURL=chunk-6TXW53UR.mjs.map