Safety Policy Gap Detection Prompt

A representative batch of refusal records from production logs, including the original request, the model's refusal response, and any metadata

500 refusal records from the last 7 days, each containing request text, refusal text, timestamp, and model version

Must be a valid JSON array. Each record must have non-empty request and refusal fields. Reject if fewer than 50 records or if all records share the same refusal reason code.

The current safety policy document that the model is supposed to follow, including allowed and disallowed categories

A markdown document with sections for prohibited content categories, edge-case guidance, and refusal criteria

Must contain explicit category definitions. Reject if document is empty, contains only generic language like 'be safe', or lacks any disallowed-category enumeration.

A structured list of safety categories the policy is expected to cover, used as the baseline for gap detection

['violence', 'hate speech', 'self-harm', 'sexual content', 'harassment', 'illegal activities', 'misinformation', 'privacy violations']

Must be a valid JSON array of strings. Each category must be a distinct, non-empty string. Reject if fewer than 3 categories or if categories overlap semantically without disambiguation.

The minimum number of refusal occurrences for a pattern to be considered a significant gap rather than noise

50

Must be a positive integer. Reject if less than 10 or greater than the total number of records in [REFUSAL_LOG_SAMPLE]. Null allowed if volume-based filtering is not desired.

A mapping of severity levels to definitions, used to prioritize gaps by potential harm

{'critical': 'imminent physical harm or illegal activity', 'high': 'significant policy violation with user impact', 'medium': 'policy boundary ambiguity', 'low': 'minor inconsistency'}

Must be a valid JSON object with at least 2 severity levels. Each level must have a non-empty definition string. Reject if definitions are circular or reference undefined levels.

The expected structure for the gap analysis output, including required fields and their types

A JSON Schema object with fields: gap_id, category, description, affected_request_count, severity, recommended_policy_addition, inconsistent_enforcement_examples

Must be a valid JSON Schema. Required fields must include at minimum: category, description, and severity. Reject if schema allows empty descriptions or missing severity assignments.

The minimum ratio of similar requests with different refusal outcomes to flag as inconsistent enforcement

0.3

Must be a float between 0.0 and 1.0. Reject if less than 0.1 or greater than 0.9. Null allowed if inconsistency detection is not required for this analysis run.

A boolean indicating whether the output should include a flag for gaps that require human policy review before action

Must be true or false. When true, the prompt must include instructions to mark gaps exceeding [RISK_SEVERITY_SCALE] critical or high levels for human review. When false, the prompt should still note severity but not require explicit review flags.

string (kebab-case)

Must match pattern ^GAP-[A-Z]{2,4}-\d{4}$. Must be unique per analysis run.

string (max 120 chars)

Must be a concise, descriptive title. Not empty. No trailing punctuation.

string (enum)

Must match one of the allowed policy area values defined in [POLICY_TAXONOMY]. Reject unknown values.

string (max 500 chars)

Must describe the missing or inconsistent coverage. Must reference at least one specific policy document or section from [POLICY_DOCS].

array of objects

Each object must contain 'refusal_id' (string), 'request_snippet' (string, max 300 chars), and 'observed_pattern' (string). Array must have 1-5 items. Validate each refusal_id exists in [REFUSAL_LOG].

string (enum)

Must be one of: 'critical', 'high', 'medium', 'low'. Severity must be consistent with [RISK_MATRIX] definitions for observed harm potential.

object

Must contain 'count' (integer, >=0) and 'period' (string enum: 'daily', 'weekly', 'monthly'). Count must not exceed total refusal log size for the period.

string (max 1000 chars)

Must propose actionable policy language. Must not contradict existing [POLICY_DOCS]. Must include explicit inclusion and exclusion criteria. Human approval required before policy update.

Output identifies at least one specific policy gap with a clear missing coverage area label.

Output returns no gaps, describes only existing policy, or lists generic categories like 'more policies needed'.

Parse output for gap list. Assert length > 0. Check that each gap has a non-empty 'missing_coverage_area' field.

Each gap is supported by at least one concrete refusal example from the provided [REFUSAL_LOG].

Gaps cite no examples, use fabricated examples, or reference examples not present in the input log.

For each gap, verify that its 'example_ids' field maps to valid entries in [REFUSAL_LOG]. Cross-reference IDs programmatically.

Output flags at least one pair of similar requests where one was refused and the other was fulfilled, with a clear explanation of the inconsistency.

Output claims perfect consistency, ignores provided borderline cases, or flags inconsistencies without explaining the policy difference.

Scan output for 'inconsistent_enforcement_examples'. Assert at least one entry has both a 'refused_request_id' and a 'fulfilled_request_id' from the log.

Each recommended policy addition includes a draft policy statement, scope boundary, and at least one test scenario.

Recommendations are vague ('clarify policy'), lack testable boundaries, or propose rules that would break existing safe behavior.

Validate each entry in 'recommended_policy_additions' has non-empty 'draft_statement', 'inclusion_criteria', and 'test_scenarios' fields. Schema check required.

Gaps are prioritized using both 'observed_request_volume' and 'risk_severity' from the input data, with explicit scores.

Prioritization is arbitrary, uses only one dimension, ignores provided volume data, or assigns identical priority to all gaps.

Check that 'priority_score' is present and derived from [REQUEST_VOLUME] and [RISK_SEVERITY] fields. Assert at least two distinct priority values across gaps.

Output distinguishes between gaps causing false refusals (over-blocking) and gaps causing missed unsafe content (under-blocking).

Output treats all gaps as the same type, conflates over-refusal with under-blocking, or omits directionality entirely.

Check 'gap_type' field for each gap. Assert that both 'false_positive_gap' and 'false_negative_gap' values appear at least once across the output.

Output is valid JSON matching the [OUTPUT_SCHEMA] with all required fields present and correctly typed.

Output is malformed JSON, missing required fields, contains string values where arrays are expected, or adds undocumented fields.

Validate output against [OUTPUT_SCHEMA] using a JSON Schema validator. Assert no validation errors. Reject on schema mismatch.

Output references only policies present in [EXISTING_POLICIES] or explicitly labels new recommendations as additions.

Output cites policies not in the provided policy set, confuses recommendations with existing rules, or fabricates policy version numbers.

Extract all policy references from output. Diff against [EXISTING_POLICIES] list. Flag any reference not found and not marked as 'recommended_addition'.