@highflame/policy 2.1.0 → 2.1.2

package/dist/explain.js

@@ -29,7 +29,8 @@
  * }
  * ```
  */
-export function explainDecision(decision, rules, context) {
+export function explainDecision(decision, rules, context, options) {
+    const provenance = options?.provenance;
     // Build lookup map: annotations.id → PolicyRule
     const ruleMap = new Map();
     for (const rule of rules) {
@@ -49,7 +50,7 @@ export function explainDecision(decision, rules, context) {
         // Recursive condition evaluation
         let evaluatedExpression;
         if (rule.conditionExpression) {
-            evaluatedExpression = evaluateExpression(rule.conditionExpression, context);
+            evaluatedExpression = evaluateExpression(rule.conditionExpression, context, provenance);
         }
         // Populate condition_results: prefer leaf extraction from expression tree,
         // fall back to flat conditions[] for backward compat with simple policies
@@ -62,7 +63,11 @@ export function explainDecision(decision, rules, context) {
             conditionResults = conditions.map(cond => {
                 const actual = context[cond.field];
                 const matched = evaluateCondition(cond.operator, actual, cond.value);
-                return { field: cond.field, operator: cond.operator, expected: cond.value, actual, matched };
+                const result = { field: cond.field, operator: cond.operator, expected: cond.value, actual, matched };
+                if (provenance?.[cond.field]) {
+                    result.source = provenance[cond.field];
+                }
+                return result;
             });
         }
         // Surface rawCondition when there are no structured conditions and no expression tree
@@ -93,19 +98,20 @@ export function explainDecision(decision, rules, context) {
 /**
  * Recursively evaluate a ConditionExpression tree against a context map.
  * Returns an EvaluatedExpression tree with `matched` booleans and `actual` values.
+ * The optional provenance map links context field names to their source detectors.
  */
-export function evaluateExpression(expr, context) {
+export function evaluateExpression(expr, context, provenance) {
     switch (expr.kind) {
         case 'and': {
-            const children = expr.children.map(c => evaluateExpression(c, context));
+            const children = expr.children.map(c => evaluateExpression(c, context, provenance));
             return { kind: 'and', children, matched: children.every(c => c.matched) };
         }
         case 'or': {
-            const children = expr.children.map(c => evaluateExpression(c, context));
+            const children = expr.children.map(c => evaluateExpression(c, context, provenance));
             return { kind: 'or', children, matched: children.some(c => c.matched) };
         }
         case 'not': {
-            const child = evaluateExpression(expr.child, context);
+            const child = evaluateExpression(expr.child, context, provenance);
             return { kind: 'not', child, matched: !child.matched };
         }
         case 'has': {
@@ -115,17 +121,26 @@ export function evaluateExpression(expr, context) {
         case 'comparison': {
             const actual = context[expr.field];
             const matched = evaluateCondition(expr.operator, actual, expr.value);
-            return { kind: 'comparison', field: expr.field, operator: expr.operator, expected: expr.value, actual, matched };
+            const result = { kind: 'comparison', field: expr.field, operator: expr.operator, expected: expr.value, actual, matched };
+            if (provenance?.[expr.field])
+                result.source = provenance[expr.field];
+            return result;
         }
         case 'contains': {
             const actual = context[expr.field];
             const matched = evaluateContains(actual, expr.value);
-            return { kind: 'contains', field: expr.field, expected: expr.value, actual, matched };
+            const result = { kind: 'contains', field: expr.field, expected: expr.value, actual, matched };
+            if (provenance?.[expr.field])
+                result.source = provenance[expr.field];
+            return result;
         }
         case 'like': {
             const actual = context[expr.field];
             const matched = evaluateLike(actual, expr.pattern);
-            return { kind: 'like', field: expr.field, pattern: expr.pattern, actual, matched };
+            const result = { kind: 'like', field: expr.field, pattern: expr.pattern, actual, matched };
+            if (provenance?.[expr.field])
+                result.source = provenance[expr.field];
+            return result;
         }
         case 'raw':
             return { kind: 'raw', text: expr.text, matched: false };
@@ -296,12 +311,24 @@ function collectLeafResults(expr) {
         case 'has':
         case 'raw':
             return [];
-        case 'comparison':
-            return [{ field: expr.field, operator: expr.operator, expected: expr.expected, actual: expr.actual, matched: expr.matched }];
-        case 'contains':
-            return [{ field: expr.field, operator: 'contains', expected: expr.expected, actual: expr.actual, matched: expr.matched }];
-        case 'like':
-            return [{ field: expr.field, operator: 'like', expected: expr.pattern, actual: expr.actual, matched: expr.matched }];
+        case 'comparison': {
+            const result = { field: expr.field, operator: expr.operator, expected: expr.expected, actual: expr.actual, matched: expr.matched };
+            if (expr.source)
+                result.source = expr.source;
+            return [result];
+        }
+        case 'contains': {
+            const result = { field: expr.field, operator: 'contains', expected: expr.expected, actual: expr.actual, matched: expr.matched };
+            if (expr.source)
+                result.source = expr.source;
+            return [result];
+        }
+        case 'like': {
+            const result = { field: expr.field, operator: 'like', expected: expr.pattern, actual: expr.actual, matched: expr.matched };
+            if (expr.source)
+                result.source = expr.source;
+            return [result];
+        }
     }
 }
 /**

package/dist/guardrails-context.gen.d.ts

@@ -7,40 +7,86 @@
 export declare const GuardrailsContextKey: {
     readonly BudgetExceeded: "budget_exceeded";
     readonly BudgetRemainingPct: "budget_remaining_pct";
+    readonly CodeLanguages: "code_languages";
+    readonly CodeRatio: "code_ratio";
+    readonly CommandInjectionDetected: "command_injection_detected";
+    readonly CommandInjectionScore: "command_injection_score";
+    readonly CommandInjectionType: "command_injection_type";
+    readonly ContainsCode: "contains_code";
     readonly ContainsInvisibleChars: "contains_invisible_chars";
+    readonly ContainsNonAscii: "contains_non_ascii";
     readonly ContainsSecrets: "contains_secrets";
+    readonly ContentSafetyBlocked: "content_safety_blocked";
+    readonly ContentSafetyScore: "content_safety_score";
     readonly ContentTopics: "content_topics";
     readonly ContentType: "content_type";
+    readonly ConversationTurn: "conversation_turn";
     readonly CrimeScore: "crime_score";
+    readonly CrossOriginDetected: "cross_origin_detected";
+    readonly CrossOriginScore: "cross_origin_score";
+    readonly CrossOriginType: "cross_origin_type";
+    readonly DetectedLanguage: "detected_language";
+    readonly DetectedScript: "detected_script";
     readonly DetectorCount: "detector_count";
     readonly Direction: "direction";
+    readonly EncodedContentDetected: "encoded_content_detected";
+    readonly EncodedCount: "encoded_count";
+    readonly EncodedScore: "encoded_score";
+    readonly EncodedTypes: "encoded_types";
+    readonly FactualityScore: "factuality_score";
+    readonly HallucinationScore: "hallucination_score";
     readonly HateSpeechScore: "hate_speech_score";
     readonly InjectionScore: "injection_score";
     readonly InjectionType: "injection_type";
     readonly InvisibleCharsScore: "invisible_chars_score";
+    readonly IsEnglish: "is_english";
+    readonly IsLatinScript: "is_latin_script";
     readonly JailbreakScore: "jailbreak_score";
+    readonly KeywordCategories: "keyword_categories";
+    readonly KeywordCount: "keyword_count";
+    readonly KeywordMatched: "keyword_matched";
+    readonly LanguageConfidence: "language_confidence";
     readonly LoopCount: "loop_count";
     readonly LoopDetected: "loop_detected";
     readonly LoopTool: "loop_tool";
+    readonly McpConfigRisk: "mcp_config_risk";
+    readonly McpRiskScore: "mcp_risk_score";
+    readonly McpRiskType: "mcp_risk_type";
     readonly McpServer: "mcp_server";
     readonly McpServerVerified: "mcp_server_verified";
     readonly McpTool: "mcp_tool";
+    readonly MultiTurnDetection: "multi_turn_detection";
+    readonly PathTraversalDetected: "path_traversal_detected";
+    readonly PathTraversalSeverity: "path_traversal_severity";
+    readonly PathTraversalType: "path_traversal_type";
     readonly PatternType: "pattern_type";
+    readonly PhishingDetected: "phishing_detected";
     readonly PiiCount: "pii_count";
     readonly PiiDetected: "pii_detected";
     readonly PiiTypes: "pii_types";
     readonly ProfanityScore: "profanity_score";
     readonly RequestId: "request_id";
+    readonly RugPullDetected: "rug_pull_detected";
+    readonly RugPullScore: "rug_pull_score";
+    readonly RugPullType: "rug_pull_type";
+    readonly ScriptConfidence: "script_confidence";
     readonly SecretCount: "secret_count";
     readonly SecretTypes: "secret_types";
+    readonly SentimentScore: "sentiment_score";
     readonly SequenceRisk: "sequence_risk";
     readonly SexualScore: "sexual_score";
+    readonly SqlInjectionDetected: "sql_injection_detected";
+    readonly SqlInjectionScore: "sql_injection_score";
+    readonly SqlInjectionType: "sql_injection_type";
     readonly SuspiciousPattern: "suspicious_pattern";
     readonly Timestamp: "timestamp";
     readonly ToolCategory: "tool_category";
     readonly ToolIsBuiltin: "tool_is_builtin";
     readonly ToolIsSensitive: "tool_is_sensitive";
     readonly ToolName: "tool_name";
+    readonly ToolPoisoningDetected: "tool_poisoning_detected";
+    readonly ToolPoisoningScore: "tool_poisoning_score";
+    readonly ToolPoisoningType: "tool_poisoning_type";
     readonly ToolRiskScore: "tool_risk_score";
     readonly TopicConfidence: "topic_confidence";
     readonly ViolenceScore: "violence_score";

package/dist/guardrails-context.gen.js

@@ -9,40 +9,86 @@
 export const GuardrailsContextKey = {
     BudgetExceeded: 'budget_exceeded',
     BudgetRemainingPct: 'budget_remaining_pct',
+    CodeLanguages: 'code_languages',
+    CodeRatio: 'code_ratio',
+    CommandInjectionDetected: 'command_injection_detected',
+    CommandInjectionScore: 'command_injection_score',
+    CommandInjectionType: 'command_injection_type',
+    ContainsCode: 'contains_code',
     ContainsInvisibleChars: 'contains_invisible_chars',
+    ContainsNonAscii: 'contains_non_ascii',
     ContainsSecrets: 'contains_secrets',
+    ContentSafetyBlocked: 'content_safety_blocked',
+    ContentSafetyScore: 'content_safety_score',
     ContentTopics: 'content_topics',
     ContentType: 'content_type',
+    ConversationTurn: 'conversation_turn',
     CrimeScore: 'crime_score',
+    CrossOriginDetected: 'cross_origin_detected',
+    CrossOriginScore: 'cross_origin_score',
+    CrossOriginType: 'cross_origin_type',
+    DetectedLanguage: 'detected_language',
+    DetectedScript: 'detected_script',
     DetectorCount: 'detector_count',
     Direction: 'direction',
+    EncodedContentDetected: 'encoded_content_detected',
+    EncodedCount: 'encoded_count',
+    EncodedScore: 'encoded_score',
+    EncodedTypes: 'encoded_types',
+    FactualityScore: 'factuality_score',
+    HallucinationScore: 'hallucination_score',
     HateSpeechScore: 'hate_speech_score',
     InjectionScore: 'injection_score',
     InjectionType: 'injection_type',
     InvisibleCharsScore: 'invisible_chars_score',
+    IsEnglish: 'is_english',
+    IsLatinScript: 'is_latin_script',
     JailbreakScore: 'jailbreak_score',
+    KeywordCategories: 'keyword_categories',
+    KeywordCount: 'keyword_count',
+    KeywordMatched: 'keyword_matched',
+    LanguageConfidence: 'language_confidence',
     LoopCount: 'loop_count',
     LoopDetected: 'loop_detected',
     LoopTool: 'loop_tool',
+    McpConfigRisk: 'mcp_config_risk',
+    McpRiskScore: 'mcp_risk_score',
+    McpRiskType: 'mcp_risk_type',
     McpServer: 'mcp_server',
     McpServerVerified: 'mcp_server_verified',
     McpTool: 'mcp_tool',
+    MultiTurnDetection: 'multi_turn_detection',
+    PathTraversalDetected: 'path_traversal_detected',
+    PathTraversalSeverity: 'path_traversal_severity',
+    PathTraversalType: 'path_traversal_type',
     PatternType: 'pattern_type',
+    PhishingDetected: 'phishing_detected',
     PiiCount: 'pii_count',
     PiiDetected: 'pii_detected',
     PiiTypes: 'pii_types',
     ProfanityScore: 'profanity_score',
     RequestId: 'request_id',
+    RugPullDetected: 'rug_pull_detected',
+    RugPullScore: 'rug_pull_score',
+    RugPullType: 'rug_pull_type',
+    ScriptConfidence: 'script_confidence',
     SecretCount: 'secret_count',
     SecretTypes: 'secret_types',
+    SentimentScore: 'sentiment_score',
     SequenceRisk: 'sequence_risk',
     SexualScore: 'sexual_score',
+    SqlInjectionDetected: 'sql_injection_detected',
+    SqlInjectionScore: 'sql_injection_score',
+    SqlInjectionType: 'sql_injection_type',
     SuspiciousPattern: 'suspicious_pattern',
     Timestamp: 'timestamp',
     ToolCategory: 'tool_category',
     ToolIsBuiltin: 'tool_is_builtin',
     ToolIsSensitive: 'tool_is_sensitive',
     ToolName: 'tool_name',
+    ToolPoisoningDetected: 'tool_poisoning_detected',
+    ToolPoisoningScore: 'tool_poisoning_score',
+    ToolPoisoningType: 'tool_poisoning_type',
     ToolRiskScore: 'tool_risk_score',
     TopicConfidence: 'topic_confidence',
     ViolenceScore: 'violence_score',

package/dist/guardrails-defaults.gen.js

@@ -423,6 +423,111 @@ forbid (
     context.budget_remaining_pct < 5 &&
     context.budget_remaining_pct > 0
 };
+
+// =============================================================================
+// Agent Security — Supply Chain & Behavioral Drift
+// =============================================================================
+
+@id("agentic-block-tool-poisoning")
+@name("Block tool poisoning attacks")
+@description("Forbids tool calls or server connections when hidden instructions or authority hijack patterns are detected in tool descriptions or arguments")
+@severity("critical")
+@tags("agentic,tool-poisoning,supply-chain")
+forbid (
+    principal,
+    action in [Guardrails::Action::"call_tool", Guardrails::Action::"connect_server"],
+    resource
+) when {
+    context has tool_poisoning_score && context.tool_poisoning_score >= 70
+};
+
+@id("agentic-block-rug-pull")
+@name("Block rug pull attacks")
+@description("Forbids tool calls when significant behavioral drift is detected (tool output deviates from established patterns)")
+@severity("high")
+@tags("agentic,rug-pull,behavioral-drift")
+forbid (
+    principal,
+    action == Guardrails::Action::"call_tool",
+    resource
+) when {
+    context has rug_pull_detected && context.rug_pull_detected == true &&
+    context has rug_pull_score && context.rug_pull_score >= 70
+};
+
+@id("agentic-block-mcp-config-risk")
+@name("Block risky MCP configurations")
+@description("Forbids tool calls or server connections when MCP configuration risks are detected (inline execution, suspicious URLs, cross-origin issues)")
+@severity("high")
+@tags("agentic,mcp-risk,supply-chain")
+forbid (
+    principal,
+    action in [Guardrails::Action::"call_tool", Guardrails::Action::"connect_server"],
+    resource
+) when {
+    context has mcp_config_risk && context.mcp_config_risk == true &&
+    context has mcp_risk_score && context.mcp_risk_score >= 70
+};
+`;
+const GUARDRAILS_SECURITY_PATTERNS_DEFAULT_CEDAR = `// =============================================================================
+// Security Pattern Detection Policy
+// =============================================================================
+// Blocks command injection, path traversal, and SQL injection attacks using
+// regex-based pattern detection from Shield's security detectors.
+//
+// Context keys used (normalized by projection layer):
+// - command_injection_detected: Bool - Command injection pattern found
+// - command_injection_score: Long (0-100) - Detection confidence
+// - path_traversal_detected: Bool - Path traversal pattern found
+// - path_traversal_severity: String - Severity level (critical/high/medium/low)
+// - sql_injection_detected: Bool - SQL injection pattern found
+// - sql_injection_score: Long (0-100) - Detection confidence
+//
+// Category: security
+// Namespace: Guardrails
+// =============================================================================
+
+@id("security-block-command-injection")
+@name("Block command injection")
+@description("Forbids requests containing command injection patterns such as reverse shells, privilege escalation, or destructive commands")
+@severity("critical")
+@tags("command-injection,security")
+forbid (
+    principal,
+    action in [Guardrails::Action::"process_prompt", Guardrails::Action::"call_tool"],
+    resource
+) when {
+    context has command_injection_detected && context.command_injection_detected == true
+};
+
+@id("security-block-path-traversal")
+@name("Block high-severity path traversal")
+@description("Forbids requests containing path traversal patterns targeting sensitive system files or using deep directory traversal")
+@severity("high")
+@tags("path-traversal,security")
+forbid (
+    principal,
+    action,
+    resource
+) when {
+    context has path_traversal_detected && context.path_traversal_detected == true &&
+    context has path_traversal_severity &&
+    (context.path_traversal_severity == "critical" || context.path_traversal_severity == "high")
+};
+
+@id("security-block-sql-injection")
+@name("Block high-confidence SQL injection")
+@description("Forbids requests with SQL injection confidence above 75% (tautologies, UNION-based, destructive queries)")
+@severity("high")
+@tags("sql-injection,security")
+forbid (
+    principal,
+    action in [Guardrails::Action::"process_prompt", Guardrails::Action::"call_tool"],
+    resource
+) when {
+    context has sql_injection_detected && context.sql_injection_detected == true &&
+    context has sql_injection_score && context.sql_injection_score >= 75
+};
 `;
 const GUARDRAILS_MCP_TOOL_PERMISSIONS_CEDAR = `// =============================================================================
 // MCP Tool Permissions Template
@@ -952,11 +1057,21 @@ export const GUARDRAILS_DEFAULTS = [
     {
         id: 'agentic-safety-default',
         name: 'Agentic Safety',
-        description: 'Block tool call loops, data exfiltration patterns, high-risk sequences, and budget violations',
+        description: 'Block tool call loops, data exfiltration patterns, high-risk sequences, budget violations, tool poisoning, rug pull attacks, and MCP configuration risks',
         category: 'agentic_security',
         cedarText: GUARDRAILS_AGENTIC_SAFETY_DEFAULT_CEDAR,
         severity: 'high',
-        tags: ['agentic', 'safety', 'loops', 'exfiltration', 'budget'],
+        tags: ['agentic', 'safety', 'loops', 'exfiltration', 'budget', 'tool-poisoning', 'rug-pull', 'mcp-risk'],
+        isActive: true,
+    },
+    {
+        id: 'security-patterns-default',
+        name: 'Security Pattern Detection',
+        description: 'Block command injection, path traversal, and SQL injection attacks using regex-based pattern detection',
+        category: 'security',
+        cedarText: GUARDRAILS_SECURITY_PATTERNS_DEFAULT_CEDAR,
+        severity: 'critical',
+        tags: ['command-injection', 'path-traversal', 'sql-injection', 'security'],
         isActive: true,
     },
 ];
@@ -1145,11 +1260,21 @@ export const GUARDRAILS_TEMPLATES_JSON = `{
     {
       "id": "agentic-safety-default",
       "name": "Agentic Safety",
-      "description": "Block tool call loops, data exfiltration patterns, high-risk sequences, and budget violations",
+      "description": "Block tool call loops, data exfiltration patterns, high-risk sequences, budget violations, tool poisoning, rug pull attacks, and MCP configuration risks",
       "category": "agentic_security",
       "file": "defaults/agentic_safety.cedar",
       "severity": "high",
-      "tags": ["agentic", "safety", "loops", "exfiltration", "budget"],
+      "tags": ["agentic", "safety", "loops", "exfiltration", "budget", "tool-poisoning", "rug-pull", "mcp-risk"],
+      "is_active": true
+    },
+    {
+      "id": "security-patterns-default",
+      "name": "Security Pattern Detection",
+      "description": "Block command injection, path traversal, and SQL injection attacks using regex-based pattern detection",
+      "category": "security",
+      "file": "defaults/security_patterns.cedar",
+      "severity": "critical",
+      "tags": ["command-injection", "path-traversal", "sql-injection", "security"],
       "is_active": true
     }
   ],

package/dist/overwatch-context.gen.d.ts

@@ -1,41 +1,61 @@
 /**
- * Context attribute keys for Overwatch Overwatch (Guardian) IDE security & policy enforcement.
+ * Context attribute keys for Overwatch Overwatch IDE agent security & policy enforcement.
  *
  * These constants correspond to the context attributes defined in the
  * Overwatch Cedar schema and are used at policy evaluation time.
  */
 export declare const OverwatchContextKey: {
+    readonly ContainsInvisibleChars: "contains_invisible_chars";
     readonly ContainsSecrets: "contains_secrets";
     readonly Content: "content";
     readonly CrimeScore: "crime_score";
     readonly Cwd: "cwd";
+    readonly DetectedThreats: "detected_threats";
     readonly Event: "event";
     readonly HateSpeechScore: "hate_speech_score";
     readonly HighestSeverity: "highest_severity";
     readonly IndirectInjectionScore: "indirect_injection_score";
     readonly InjectionConfidence: "injection_confidence";
+    readonly InvisibleCharsScore: "invisible_chars_score";
     readonly JailbreakConfidence: "jailbreak_confidence";
+    readonly LoopCount: "loop_count";
+    readonly LoopDetected: "loop_detected";
+    readonly LoopTool: "loop_tool";
     readonly MaxThreatSeverity: "max_threat_severity";
+    readonly McpConfigRisk: "mcp_config_risk";
+    readonly McpRiskScore: "mcp_risk_score";
     readonly McpServer: "mcp_server";
     readonly McpServerVerified: "mcp_server_verified";
     readonly McpTool: "mcp_tool";
     readonly Path: "path";
+    readonly PatternType: "pattern_type";
     readonly PiiConfidence: "pii_confidence";
+    readonly PiiCount: "pii_count";
+    readonly PiiDetected: "pii_detected";
+    readonly PiiTypes: "pii_types";
     readonly ProfanityScore: "profanity_score";
     readonly PromptText: "prompt_text";
     readonly ResponseContent: "response_content";
+    readonly RugPullDetected: "rug_pull_detected";
     readonly RugPullScore: "rug_pull_score";
+    readonly SecretCount: "secret_count";
+    readonly SecretTypes: "secret_types";
+    readonly SequenceRisk: "sequence_risk";
     readonly SexualScore: "sexual_score";
     readonly Source: "source";
+    readonly SuspiciousPattern: "suspicious_pattern";
     readonly ThreatCategories: "threat_categories";
     readonly ThreatCount: "threat_count";
-    readonly ThreatTypes: "threat_types";
+    readonly ToolCategory: "tool_category";
+    readonly ToolIsBuiltin: "tool_is_builtin";
+    readonly ToolIsSensitive: "tool_is_sensitive";
     readonly ToolName: "tool_name";
+    readonly ToolPoisoningDetected: "tool_poisoning_detected";
     readonly ToolPoisoningScore: "tool_poisoning_score";
+    readonly ToolRiskScore: "tool_risk_score";
     readonly UserEmail: "user_email";
     readonly ViolenceScore: "violence_score";
     readonly WeaponsScore: "weapons_score";
     readonly WorkspaceRoot: "workspace_root";
-    readonly YaraThreats: "yara_threats";
 };
 export type OverwatchContextKey = (typeof OverwatchContextKey)[keyof typeof OverwatchContextKey];

package/dist/overwatch-context.gen.js

@@ -1,42 +1,62 @@
 // Code generated by highflame-policy-codegen. DO NOT EDIT.
 // Source: schemas/overwatch/context.json
 /**
- * Context attribute keys for Overwatch Overwatch (Guardian) IDE security & policy enforcement.
+ * Context attribute keys for Overwatch Overwatch IDE agent security & policy enforcement.
  *
  * These constants correspond to the context attributes defined in the
  * Overwatch Cedar schema and are used at policy evaluation time.
  */
 export const OverwatchContextKey = {
+    ContainsInvisibleChars: 'contains_invisible_chars',
     ContainsSecrets: 'contains_secrets',
     Content: 'content',
     CrimeScore: 'crime_score',
     Cwd: 'cwd',
+    DetectedThreats: 'detected_threats',
     Event: 'event',
     HateSpeechScore: 'hate_speech_score',
     HighestSeverity: 'highest_severity',
     IndirectInjectionScore: 'indirect_injection_score',
     InjectionConfidence: 'injection_confidence',
+    InvisibleCharsScore: 'invisible_chars_score',
     JailbreakConfidence: 'jailbreak_confidence',
+    LoopCount: 'loop_count',
+    LoopDetected: 'loop_detected',
+    LoopTool: 'loop_tool',
     MaxThreatSeverity: 'max_threat_severity',
+    McpConfigRisk: 'mcp_config_risk',
+    McpRiskScore: 'mcp_risk_score',
     McpServer: 'mcp_server',
     McpServerVerified: 'mcp_server_verified',
     McpTool: 'mcp_tool',
     Path: 'path',
+    PatternType: 'pattern_type',
     PiiConfidence: 'pii_confidence',
+    PiiCount: 'pii_count',
+    PiiDetected: 'pii_detected',
+    PiiTypes: 'pii_types',
     ProfanityScore: 'profanity_score',
     PromptText: 'prompt_text',
     ResponseContent: 'response_content',
+    RugPullDetected: 'rug_pull_detected',
     RugPullScore: 'rug_pull_score',
+    SecretCount: 'secret_count',
+    SecretTypes: 'secret_types',
+    SequenceRisk: 'sequence_risk',
     SexualScore: 'sexual_score',
     Source: 'source',
+    SuspiciousPattern: 'suspicious_pattern',
     ThreatCategories: 'threat_categories',
     ThreatCount: 'threat_count',
-    ThreatTypes: 'threat_types',
+    ToolCategory: 'tool_category',
+    ToolIsBuiltin: 'tool_is_builtin',
+    ToolIsSensitive: 'tool_is_sensitive',
     ToolName: 'tool_name',
+    ToolPoisoningDetected: 'tool_poisoning_detected',
     ToolPoisoningScore: 'tool_poisoning_score',
+    ToolRiskScore: 'tool_risk_score',
     UserEmail: 'user_email',
     ViolenceScore: 'violence_score',
     WeaponsScore: 'weapons_score',
     WorkspaceRoot: 'workspace_root',
-    YaraThreats: 'yara_threats',
 };

package/dist/overwatch-defaults.gen.d.ts

@@ -2,7 +2,7 @@
  * Overwatch policy category identifiers.
  * Maps to UI tab names in Studio.
  */
-export type OverwatchCategory = 'secrets' | 'pii' | 'semantic' | 'tools' | 'organization' | 'trust_safety' | 'agent_security';
+export type OverwatchCategory = 'secrets' | 'pii' | 'semantic' | 'tools' | 'organization' | 'trust_safety' | 'agent_security' | 'encoding' | 'behavioral';
 /**
  * Category metadata for UI display.
  */