@dotsetlabs/bellwether 1.0.3 → 2.0.0

package/dist/baseline/comparator.js

@@ -11,12 +11,12 @@
  */
 import { createBaseline } from './saver.js';
 import { getToolFingerprints } from './accessors.js';
-import { compareFingerprints, compareErrorPatterns, } from './response-fingerprint.js';
+import { compareFingerprints, compareErrorPatterns } from './response-fingerprint.js';
 import { analyzeErrorTrends } from './error-analyzer.js';
 import { compareSecurityFingerprints } from '../security/security-tester.js';
 import { compareSchemaEvolution } from './response-schema-tracker.js';
 import { checkVersionCompatibility, BaselineVersionError, parseVersion, areVersionsCompatible, getCompatibilityWarning, } from './version.js';
-import { compareSchemas } from './schema-compare.js';
+import { compareSchemas, computeSchemaHash } from './schema-compare.js';
 import { PERFORMANCE_TRACKING } from '../constants.js';
 import { hasReliableConfidence } from './performance-tracker.js';
 import { compareDocumentationScores, scoreDocumentation } from './documentation-scorer.js';
@@ -89,6 +89,11 @@ export function compareBaselines(previous, current, options = {}) {
             behaviorChanges.push(...toolDiff.changes);
         }
     }
+    // Compare prompts and resources
+    behaviorChanges.push(...comparePrompts(previous.capabilities.prompts, current.capabilities.prompts));
+    behaviorChanges.push(...compareResources(previous.capabilities.resources, current.capabilities.resources));
+    // Compare server metadata and capabilities
+    behaviorChanges.push(...compareServerInfo(previous.server, current.server));
     // Compare workflows
     const workflowChanges = compareWorkflows(previous.workflows || [], current.workflows || []);
     behaviorChanges.push(...workflowChanges);
@@ -131,8 +136,10 @@ function compareTool(previous, current, options) {
     let responseSchemaEvolutionChanged = false;
     let securityChanged = false;
     let schemaEvolutionDiff;
-    // Compare input schema with detailed diff
-    if (previous.schemaHash !== current.schemaHash && !options.ignoreSchemaChanges) {
+    // Compare input schema with detailed diff (declared schema hash)
+    const previousDeclaredHash = getDeclaredSchemaHash(previous);
+    const currentDeclaredHash = getDeclaredSchemaHash(current);
+    if (previousDeclaredHash !== currentDeclaredHash && !options.ignoreSchemaChanges) {
         schemaChanged = true;
         // Get detailed schema comparison if inputSchema is available on both
         const schemaComparison = compareSchemas(previous.inputSchema, current.inputSchema);
@@ -155,8 +162,8 @@ function compareTool(previous, current, options) {
             changes.push({
                 tool: current.name,
                 aspect: 'schema',
-                before: `Schema hash: ${previous.schemaHash}`,
-                after: `Schema hash: ${current.schemaHash}`,
+                before: `Schema hash: ${previousDeclaredHash}`,
+                after: `Schema hash: ${currentDeclaredHash}`,
                 severity: 'breaking',
                 description: `Schema for ${current.name} has changed`,
             });
@@ -314,6 +321,235 @@ function compareTool(previous, current, options) {
         schemaEvolutionDiff,
     };
 }
+function comparePrompts(previous, current) {
+    const changes = [];
+    const prevMap = new Map((previous ?? []).map((p) => [p.name, p]));
+    const currMap = new Map((current ?? []).map((p) => [p.name, p]));
+    for (const [name, currPrompt] of currMap) {
+        const prevPrompt = prevMap.get(name);
+        if (!prevPrompt) {
+            changes.push({
+                tool: `prompt:${name}`,
+                aspect: 'prompt',
+                before: 'absent',
+                after: 'present',
+                severity: 'info',
+                description: `Prompt "${name}" added`,
+            });
+            continue;
+        }
+        if (prevPrompt.description !== currPrompt.description) {
+            changes.push({
+                tool: `prompt:${name}`,
+                aspect: 'prompt',
+                before: prevPrompt.description ?? 'none',
+                after: currPrompt.description ?? 'none',
+                severity: 'info',
+                description: `Prompt "${name}" description changed`,
+            });
+        }
+        const prevArgs = prevPrompt.arguments ?? [];
+        const currArgs = currPrompt.arguments ?? [];
+        const prevArgMap = new Map(prevArgs.map((a) => [a.name, a]));
+        const currArgMap = new Map(currArgs.map((a) => [a.name, a]));
+        for (const [argName, currArg] of currArgMap) {
+            const prevArg = prevArgMap.get(argName);
+            if (!prevArg) {
+                changes.push({
+                    tool: `prompt:${name}`,
+                    aspect: 'prompt',
+                    before: 'absent',
+                    after: 'present',
+                    severity: currArg.required ? 'breaking' : 'info',
+                    description: `Prompt "${name}" argument "${argName}" added`,
+                });
+                continue;
+            }
+            if (prevArg.required !== currArg.required) {
+                changes.push({
+                    tool: `prompt:${name}`,
+                    aspect: 'prompt',
+                    before: String(prevArg.required ?? false),
+                    after: String(currArg.required ?? false),
+                    severity: currArg.required ? 'breaking' : 'warning',
+                    description: `Prompt "${name}" argument "${argName}" requirement changed`,
+                });
+            }
+            if (prevArg.description !== currArg.description) {
+                changes.push({
+                    tool: `prompt:${name}`,
+                    aspect: 'prompt',
+                    before: prevArg.description ?? 'none',
+                    after: currArg.description ?? 'none',
+                    severity: 'info',
+                    description: `Prompt "${name}" argument "${argName}" description changed`,
+                });
+            }
+        }
+        for (const [argName] of prevArgMap) {
+            if (!currArgMap.has(argName)) {
+                changes.push({
+                    tool: `prompt:${name}`,
+                    aspect: 'prompt',
+                    before: 'present',
+                    after: 'absent',
+                    severity: 'breaking',
+                    description: `Prompt "${name}" argument "${argName}" removed`,
+                });
+            }
+        }
+    }
+    for (const [name] of prevMap) {
+        if (!currMap.has(name)) {
+            changes.push({
+                tool: `prompt:${name}`,
+                aspect: 'prompt',
+                before: 'present',
+                after: 'absent',
+                severity: 'breaking',
+                description: `Prompt "${name}" removed`,
+            });
+        }
+    }
+    return changes;
+}
+function compareResources(previous, current) {
+    const changes = [];
+    const prevMap = new Map((previous ?? []).map((r) => [r.uri, r]));
+    const currMap = new Map((current ?? []).map((r) => [r.uri, r]));
+    for (const [uri, currResource] of currMap) {
+        const prevResource = prevMap.get(uri);
+        if (!prevResource) {
+            changes.push({
+                tool: `resource:${currResource.name ?? uri}`,
+                aspect: 'resource',
+                before: 'absent',
+                after: 'present',
+                severity: 'info',
+                description: `Resource "${uri}" added`,
+            });
+            continue;
+        }
+        if (prevResource.name !== currResource.name) {
+            changes.push({
+                tool: `resource:${currResource.name ?? uri}`,
+                aspect: 'resource',
+                before: prevResource.name ?? 'none',
+                after: currResource.name ?? 'none',
+                severity: 'info',
+                description: `Resource "${uri}" name changed`,
+            });
+        }
+        if (prevResource.description !== currResource.description) {
+            changes.push({
+                tool: `resource:${currResource.name ?? uri}`,
+                aspect: 'resource',
+                before: prevResource.description ?? 'none',
+                after: currResource.description ?? 'none',
+                severity: 'info',
+                description: `Resource "${uri}" description changed`,
+            });
+        }
+        if (prevResource.mimeType !== currResource.mimeType) {
+            changes.push({
+                tool: `resource:${currResource.name ?? uri}`,
+                aspect: 'resource',
+                before: prevResource.mimeType ?? 'none',
+                after: currResource.mimeType ?? 'none',
+                severity: 'warning',
+                description: `Resource "${uri}" mime type changed`,
+            });
+        }
+    }
+    for (const [uri, prevResource] of prevMap) {
+        if (!currMap.has(uri)) {
+            changes.push({
+                tool: `resource:${prevResource.name ?? uri}`,
+                aspect: 'resource',
+                before: 'present',
+                after: 'absent',
+                severity: 'breaking',
+                description: `Resource "${uri}" removed`,
+            });
+        }
+    }
+    return changes;
+}
+function compareServerInfo(previous, current) {
+    const changes = [];
+    if (previous.name !== current.name) {
+        changes.push({
+            tool: 'server',
+            aspect: 'server',
+            before: previous.name,
+            after: current.name,
+            severity: 'info',
+            description: 'Server name changed',
+        });
+    }
+    if (previous.version !== current.version) {
+        changes.push({
+            tool: 'server',
+            aspect: 'server',
+            before: previous.version,
+            after: current.version,
+            severity: 'info',
+            description: 'Server version changed',
+        });
+    }
+    if (previous.protocolVersion !== current.protocolVersion) {
+        const breaking = isMajorVersionChange(previous.protocolVersion, current.protocolVersion);
+        changes.push({
+            tool: 'server',
+            aspect: 'server',
+            before: previous.protocolVersion,
+            after: current.protocolVersion,
+            severity: breaking ? 'breaking' : 'warning',
+            description: 'Protocol version changed',
+        });
+    }
+    const prevCaps = new Set(previous.capabilities);
+    const currCaps = new Set(current.capabilities);
+    for (const cap of prevCaps) {
+        if (!currCaps.has(cap)) {
+            changes.push({
+                tool: 'server',
+                aspect: 'capability',
+                before: cap,
+                after: 'removed',
+                severity: 'breaking',
+                description: `Capability "${cap}" removed`,
+            });
+        }
+    }
+    for (const cap of currCaps) {
+        if (!prevCaps.has(cap)) {
+            changes.push({
+                tool: 'server',
+                aspect: 'capability',
+                before: 'absent',
+                after: cap,
+                severity: 'info',
+                description: `Capability "${cap}" added`,
+            });
+        }
+    }
+    return changes;
+}
+function isMajorVersionChange(previous, current) {
+    const prevMajor = parseInt(previous.split('.')[0] ?? '0', 10);
+    const currMajor = parseInt(current.split('.')[0] ?? '0', 10);
+    if (Number.isNaN(prevMajor) || Number.isNaN(currMajor)) {
+        return previous !== current;
+    }
+    return prevMajor !== currMajor;
+}
+function getDeclaredSchemaHash(tool) {
+    if (tool.inputSchema && Object.keys(tool.inputSchema).length > 0) {
+        return computeSchemaHash(tool.inputSchema);
+    }
+    return tool.schemaHash;
+}
 /**
  * Format a schema change value for display in BehaviorChange.
  * Converts unknown values to human-readable strings.
@@ -331,8 +567,11 @@ function formatSchemaChangeValue(value) {
         if (value.length === 0)
             return '[]';
         if (value.length <= 3)
-            return `[${value.map(v => formatSchemaChangeValue(v)).join(', ')}]`;
-        return `[${value.slice(0, 3).map(v => formatSchemaChangeValue(v)).join(', ')}, ...]`;
+            return `[${value.map((v) => formatSchemaChangeValue(v)).join(', ')}]`;
+        return `[${value
+            .slice(0, 3)
+            .map((v) => formatSchemaChangeValue(v))
+            .join(', ')}, ...]`;
     }
     // For objects, show a compact representation
     try {
@@ -474,7 +713,7 @@ export function applyAspectOverride(change, aspectOverrides) {
  * Returns a new diff with filtered/modified changes based on config.
  */
 export function applySeverityConfig(diff, config) {
-    const { minimumSeverity = 'none', suppressWarnings = false, aspectOverrides, } = config;
+    const { minimumSeverity = 'none', suppressWarnings = false, aspectOverrides } = config;
     // Apply aspect overrides and filter by minimum severity
     const filteredChanges = diff.behaviorChanges
         .map((change) => {
@@ -495,8 +734,7 @@ export function applySeverityConfig(diff, config) {
     // Filter toolsModified to only include those with remaining changes
     const toolsWithChanges = new Set(filteredChanges.map((c) => c.tool));
     const filteredToolsModified = diff.toolsModified.filter((td) => toolsWithChanges.has(td.tool) ||
-        (td.schemaChanged &&
-            (!aspectOverrides?.schema || aspectOverrides.schema !== 'none')) ||
+        (td.schemaChanged && (!aspectOverrides?.schema || aspectOverrides.schema !== 'none')) ||
         (td.descriptionChanged &&
             (!aspectOverrides?.description || aspectOverrides.description !== 'none')));
     // Recalculate counts

package/dist/baseline/converter.d.ts

@@ -1,5 +1,5 @@
 /**
- * Cloud baseline builder.
+ * Baseline builder.
  *
  * ## Severity Type Mappings
  *
@@ -13,19 +13,19 @@
  * Used for error severity classification in error handling.
  * Values: 'low' | 'medium' | 'high' | 'critical'
  *
- * ### CloudAssertionSeverity (cloud/types.ts)
- * Used for cloud assertions and PersonaFinding severity levels.
+ * ### BaselineAssertionSeverity (baseline-format.ts)
+ * Used for baseline assertions and PersonaFinding severity levels.
  * Values: 'info' | 'low' | 'medium' | 'high' | 'critical'
  *
  * ### Conversion Mappings
  *
- * ChangeSeverity → CloudAssertionSeverity:
+ * ChangeSeverity → BaselineAssertionSeverity:
  * - 'none'     → 'info'     (no change, informational)
  * - 'info'     → 'low'      (minor changes)
  * - 'warning'  → 'medium'   (moderate changes)
  * - 'breaking' → 'critical' (breaking changes)
  *
- * CloudAssertionSeverity → ChangeSeverity (for display/filtering):
+ * BaselineAssertionSeverity → ChangeSeverity (for display/filtering):
  * - 'info'     → 'info'
  * - 'low'      → 'info'
  * - 'medium'   → 'warning'
@@ -34,25 +34,25 @@
  */
 import type { BehavioralAssertion, BehavioralBaseline, ChangeSeverity } from './types.js';
 import type { InterviewResult } from '../interview/types.js';
-import type { CloudAssertion, CloudAssertionSeverity } from './cloud-types.js';
+import type { BaselineAssertion, BaselineAssertionSeverity } from './baseline-format.js';
 /**
- * Map ChangeSeverity to CloudAssertionSeverity.
- * Used when mapping CLI assertions to cloud severity levels.
+ * Map ChangeSeverity to BaselineAssertionSeverity.
+ * Used when mapping CLI assertions to baseline severity levels.
  */
-export declare const CHANGE_TO_CLOUD_SEVERITY: Record<ChangeSeverity, CloudAssertionSeverity>;
+export declare const CHANGE_TO_BASELINE_SEVERITY: Record<ChangeSeverity, BaselineAssertionSeverity>;
 /**
- * Map CloudAssertionSeverity to ChangeSeverity.
- * Used when filtering or displaying cloud data locally.
+ * Map BaselineAssertionSeverity to ChangeSeverity.
+ * Used when filtering or displaying baseline data locally.
  */
-export declare const CLOUD_TO_CHANGE_SEVERITY: Record<CloudAssertionSeverity, ChangeSeverity>;
+export declare const BASELINE_TO_CHANGE_SEVERITY: Record<BaselineAssertionSeverity, ChangeSeverity>;
 /**
- * Convert an array of BehavioralAssertions to CloudAssertions.
+ * Convert an array of BehavioralAssertions to baseline assertions.
  */
-export declare function convertAssertions(assertions: BehavioralAssertion[]): CloudAssertion[];
+export declare function convertAssertions(assertions: BehavioralAssertion[]): BaselineAssertion[];
 /**
  * Create a BellwetherBaseline directly from InterviewResult.
  *
  * This is the preferred method when you have fresh interview results.
  */
-export declare function createCloudBaseline(result: InterviewResult, serverCommand: string): BehavioralBaseline;
+export declare function createBaselineFromInterview(result: InterviewResult, serverCommand: string): BehavioralBaseline;
 //# sourceMappingURL=converter.d.ts.map

package/dist/baseline/converter.js

@@ -1,5 +1,5 @@
 /**
- * Cloud baseline builder.
+ * Baseline builder.
  *
  * ## Severity Type Mappings
  *
@@ -13,19 +13,19 @@
  * Used for error severity classification in error handling.
  * Values: 'low' | 'medium' | 'high' | 'critical'
  *
- * ### CloudAssertionSeverity (cloud/types.ts)
- * Used for cloud assertions and PersonaFinding severity levels.
+ * ### BaselineAssertionSeverity (baseline-format.ts)
+ * Used for baseline assertions and PersonaFinding severity levels.
  * Values: 'info' | 'low' | 'medium' | 'high' | 'critical'
  *
  * ### Conversion Mappings
  *
- * ChangeSeverity → CloudAssertionSeverity:
+ * ChangeSeverity → BaselineAssertionSeverity:
  * - 'none'     → 'info'     (no change, informational)
  * - 'info'     → 'low'      (minor changes)
  * - 'warning'  → 'medium'   (moderate changes)
  * - 'breaking' → 'critical' (breaking changes)
  *
- * CloudAssertionSeverity → ChangeSeverity (for display/filtering):
+ * BaselineAssertionSeverity → ChangeSeverity (for display/filtering):
  * - 'info'     → 'info'
  * - 'low'      → 'info'
  * - 'medium'   → 'warning'
@@ -35,27 +35,27 @@
 import { createHash } from 'crypto';
 import { analyzeResponses } from './response-fingerprint.js';
 import { buildSchemaEvolution } from './response-schema-tracker.js';
-import { calculateMetrics, calculatePerformanceConfidence } from './performance-tracker.js';
-import { computeConsensusSchemaHash } from './schema-compare.js';
+import { calculateMetrics, calculatePerformanceConfidence, } from './performance-tracker.js';
+import { computeConsensusSchemaHash, computeSchemaHash } from './schema-compare.js';
 import { calculateBaselineHash } from './baseline-hash.js';
 import { getBaselineVersion } from './version.js';
 import { VERSION } from '../version.js';
 import { scoreDocumentation, toDocumentationScoreSummary } from './documentation-scorer.js';
 /**
- * Map ChangeSeverity to CloudAssertionSeverity.
- * Used when mapping CLI assertions to cloud severity levels.
+ * Map ChangeSeverity to BaselineAssertionSeverity.
+ * Used when mapping CLI assertions to baseline severity levels.
  */
-export const CHANGE_TO_CLOUD_SEVERITY = {
+export const CHANGE_TO_BASELINE_SEVERITY = {
     none: 'info',
     info: 'low',
     warning: 'medium',
     breaking: 'critical',
 };
 /**
- * Map CloudAssertionSeverity to ChangeSeverity.
- * Used when filtering or displaying cloud data locally.
+ * Map BaselineAssertionSeverity to ChangeSeverity.
+ * Used when filtering or displaying baseline data locally.
  */
-export const CLOUD_TO_CHANGE_SEVERITY = {
+export const BASELINE_TO_CHANGE_SEVERITY = {
     info: 'info',
     low: 'info',
     medium: 'warning',
@@ -69,7 +69,7 @@ function hashString(input) {
     return createHash('sha256').update(input).digest('hex').slice(0, 16);
 }
 /**
- * Convert a local BehavioralAssertion to cloud CloudAssertion format.
+ * Convert a local BehavioralAssertion to baseline assertion format.
  *
  * Mapping:
  * - isPositive=true + security aspect → 'requires' (critical security requirement)
@@ -123,7 +123,7 @@ function convertAssertion(assertion) {
     };
 }
 /**
- * Convert an array of BehavioralAssertions to CloudAssertions.
+ * Convert an array of BehavioralAssertions to baseline assertions.
  */
 export function convertAssertions(assertions) {
     return assertions.map(convertAssertion);
@@ -132,17 +132,15 @@ export function convertAssertions(assertions) {
  * Derive baseline mode from result metadata.
  * Returns 'check' for check mode results, 'explore' for explore mode results.
  * Note: Baselines should only be created from check mode results,
- * but explore uploads are still supported for documentation tracking.
+ * but explore mode baselines are still supported for documentation tracking.
  */
-function deriveCloudMode(resultModel, baselineMode) {
+function deriveBaselineMode(resultModel) {
     // Check mode results have model === 'check'
     if (resultModel === 'check')
         return 'check';
     // LLM model names indicate explore mode
     if (resultModel)
         return 'explore';
-    if (baselineMode === 'check')
-        return 'check';
     // Default to check for legacy baselines without explicit mode
     return 'check';
 }
@@ -296,9 +294,7 @@ function classifySeverity(note) {
         lowerNote.includes('leak')) {
         return 'medium';
     }
-    if (lowerNote.includes('low') ||
-        lowerNote.includes('minor') ||
-        lowerNote.includes('potential')) {
+    if (lowerNote.includes('low') || lowerNote.includes('minor') || lowerNote.includes('potential')) {
         return 'low';
     }
     return 'info';
@@ -308,9 +304,9 @@ function classifySeverity(note) {
  *
  * This is the preferred method when you have fresh interview results.
  */
-export function createCloudBaseline(result, serverCommand) {
+export function createBaselineFromInterview(result, serverCommand) {
     // Derive mode from result metadata
-    const mode = deriveCloudMode(result.metadata.model);
+    const mode = deriveBaselineMode(result.metadata.model);
     // Build metadata
     const metadata = {
         mode,
@@ -338,11 +334,12 @@ export function createCloudBaseline(result, serverCommand) {
         }
     }
     const tools = result.toolProfiles.map((profile) => {
-        const interactions = profile.interactions.map(i => ({ args: i.question.args }));
-        const { hash: schemaHash } = computeConsensusSchemaHash(interactions);
+        const interactions = profile.interactions.map((i) => ({ args: i.question.args }));
+        const observedSchema = computeConsensusSchemaHash(interactions);
+        const declaredSchemaHash = computeSchemaHash(schemaMap.get(profile.name) ?? {});
         const responseData = profile.interactions
-            .filter(i => !i.mocked)
-            .map(i => ({
+            .filter((i) => !i.mocked)
+            .map((i) => ({
             response: i.response,
             error: i.error,
         }));
@@ -351,8 +348,8 @@ export function createCloudBaseline(result, serverCommand) {
             ? buildSchemaEvolution(responseAnalysis.schemas)
             : undefined;
         const latencySamples = profile.interactions
-            .filter(i => i.toolExecutionMs !== undefined && !i.mocked)
-            .map(i => ({
+            .filter((i) => i.toolExecutionMs !== undefined && !i.mocked)
+            .map((i) => ({
             toolName: profile.name,
             durationMs: i.toolExecutionMs ?? 0,
             success: !i.error && !i.response?.isError,
@@ -378,16 +375,23 @@ export function createCloudBaseline(result, serverCommand) {
             name: profile.name,
             description: profile.description ?? '',
             inputSchema: schemaMap.get(profile.name) ?? {},
-            schemaHash,
+            schemaHash: declaredSchemaHash,
+            observedArgsSchemaHash: observedSchema.hash,
+            observedArgsSchemaConsistency: observedSchema.consistency,
+            observedArgsSchemaVariations: observedSchema.variations,
             responseFingerprint: responseAnalysis.fingerprint,
             inferredOutputSchema: responseAnalysis.inferredSchema,
             responseSchemaEvolution,
-            errorPatterns: responseAnalysis.errorPatterns.length ? responseAnalysis.errorPatterns : undefined,
+            errorPatterns: responseAnalysis.errorPatterns.length
+                ? responseAnalysis.errorPatterns
+                : undefined,
             baselineP50Ms,
             baselineP95Ms,
             baselineP99Ms,
             baselineSuccessRate,
             performanceConfidence,
+            lastTestedAt: metadata.generatedAt,
+            inputSchemaHashAtTest: declaredSchemaHash,
         };
     });
     const prompts = result.discovery.prompts.length > 0
@@ -401,6 +405,14 @@ export function createCloudBaseline(result, serverCommand) {
             })),
         }))
         : undefined;
+    const resources = result.discovery.resources && result.discovery.resources.length > 0
+        ? result.discovery.resources.map((r) => ({
+            uri: r.uri,
+            name: r.name,
+            description: r.description,
+            mimeType: r.mimeType,
+        }))
+        : undefined;
     // Build interviews
     const interviews = buildInterviews(result, mode);
     // Build tool profiles (with converted assertions)
@@ -425,13 +437,13 @@ export function createCloudBaseline(result, serverCommand) {
         summary: wr.summary,
     }));
     const documentationScore = toDocumentationScoreSummary(scoreDocumentation(result.discovery.tools));
-    // Build assertions (convert to cloud format)
+    // Build assertions (convert to baseline format)
     const assertions = convertAssertions(extractAllAssertions(result));
     const baselineWithoutHash = {
         version: getBaselineVersion(),
         metadata,
         server,
-        capabilities: { tools, prompts },
+        capabilities: { tools, prompts, resources },
         interviews,
         toolProfiles,
         workflows,

package/dist/baseline/diff.d.ts

@@ -38,7 +38,7 @@ export declare function formatDiffJUnit(diff: BehavioralDiff, suiteName?: string
  * Format diff as SARIF (Static Analysis Results Interchange Format) for GitHub Code Scanning.
  *
  * SARIF is the standard format for GitHub's code scanning feature and can be
- * uploaded to show drift detection results in pull request reviews.
+ * used to show drift detection results in pull request reviews.
  *
  * @see https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html
  *