Diagnostic Context Packaging Prompt for Human Review

This prompt is designed for a specific job: formatting a pre-flagged anomaly into a structured, self-contained review item for a human operator. It is not a detection or decision-making prompt. An upstream system—such as a distribution shift detector, a policy violation classifier, or a low-confidence gate—must have already identified the case and triggered the escalation workflow. The prompt's sole responsibility is to assemble the diagnostic evidence into a clear, standardized payload so a human reviewer can grasp the situation, assess its urgency, and make a decision without needing to query logs, replay a session, or reconstruct the model's state from scratch.

The ideal users are operations teams, AI safety engineers, and product reliability engineers who manage human-in-the-loop review queues. They use this prompt to enforce a consistent schema for all escalations, which reduces the cognitive load on reviewers, standardizes audit trails, and allows for downstream analysis of review patterns. The prompt requires a rich set of inputs to be effective: the original triggering input, the model's output or planned action, relevant session history, the specific diagnostic signals that caused the flag (e.g., anomaly scores, violated policy clauses, uncertainty metrics), and any available metadata like timestamps or session IDs. Without this context, the packaged review item will be incomplete, forcing the reviewer to do investigative work and defeating the prompt's purpose.

Do not use this prompt to make the escalation decision itself, to classify the type of anomaly, or to instruct the human reviewer on what decision to make. Its function is strictly presentational and contextual. If you need a prompt to detect a novel input, classify a failure mode, or score a risk, you should use a dedicated detection prompt from the Edge Case Detection and Escalation pillar. This prompt is the final formatting step in the pipeline, transforming machine-readable diagnostic data into a human-readable review package. Before deploying, validate that your upstream detection systems are providing all required fields; an incomplete input to this prompt will produce an incomplete review item, creating a bottleneck in your human review process.

This prompt template is designed to be inserted into an escalation workflow where an AI system has encountered an edge case, low-confidence state, or policy boundary and needs to hand off to a human reviewer. The template forces the model to assemble a complete, structured review item rather than a vague summary. It separates the triggering input from the model's internal state, relevant history, and diagnostic signals, ensuring the human reviewer receives everything needed to make a fast, informed decision without hunting through logs.

textCopy
You are a diagnostic escalation formatter. Your job is to package a machine-generated escalation into a structured review item for a human operator. Do not make the decision. Do not guess what the human would do. Package the evidence.

## INPUT
[ESCALATION_TRIGGER]

## MODEL STATE
[AGENT_STATE]

## RELEVANT HISTORY
[CONVERSATION_OR_ACTION_HISTORY]

## DIAGNOSTIC SIGNALS
[DIAGNOSTIC_SIGNALS]

## CONSTRAINTS
- Do not omit any diagnostic signal provided.
- If a signal is missing or null, mark it as "UNAVAILABLE" rather than inventing a value.
- Classify urgency as one of: CRITICAL, HIGH, MEDIUM, LOW.
- CRITICAL: immediate safety, legal, or irreversible-action risk.
- HIGH: likely wrong outcome if not reviewed within [SLA_TIMEFRAME].
- MEDIUM: review required but no immediate harm expected.
- LOW: informational escalation, no action required.

## OUTPUT SCHEMA
Return a JSON object with exactly these fields:
{
  "escalation_id": "string, unique identifier for this escalation",
  "urgency": "CRITICAL | HIGH | MEDIUM | LOW",
  "urgency_rationale": "string, one-sentence explanation of urgency classification",
  "trigger_summary": "string, concise description of what triggered the escalation",
  "trigger_input": "string, the exact input or event that caused the escalation",
  "model_state_snapshot": {
    "current_intent": "string, what the model was trying to do",
    "confidence": "number 0.0-1.0 or null if unavailable",
    "uncertainty_source": "string, what the model is uncertain about",
    "active_constraints": ["string, constraints the model was operating under"]
  },
  "relevant_context": {
    "history_summary": "string, condensed relevant history",
    "key_entities": ["string, important entities mentioned"],
    "prior_decisions": ["string, decisions already made in this session"]
  },
  "diagnostic_breakdown": [
    {
      "signal_name": "string, name of the diagnostic signal",
      "signal_value": "string, observed value",
      "expected_range": "string, normal operating range or null",
      "deviation_flag": "boolean, whether this signal is outside expected range"
    }
  ],
  "recommended_review_questions": ["string, specific questions the reviewer should answer"],
  "raw_log_reference": "string, pointer to full logs for deeper investigation"
}

Adaptation notes: Replace each square-bracket placeholder with the actual data available in your system. [ESCALATION_TRIGGER] should contain the exact input, event, or threshold breach that caused the escalation. [AGENT_STATE] should include the model's current intent, confidence scores, and active constraints. [CONVERSATION_OR_ACTION_HISTORY] should be a condensed but complete record of relevant prior turns or actions. [DIAGNOSTIC_SIGNALS] should include any anomaly scores, distribution drift metrics, policy violation flags, or uncertainty measurements your system produces. [SLA_TIMEFRAME] should be replaced with your team's actual review SLA. If your system does not produce certain fields, remove them from the schema rather than forcing the model to hallucinate values. For high-risk domains, add a [RISK_LEVEL] parameter and require explicit human sign-off fields in the output.

The diagnostic context packaging prompt is designed to sit at the boundary between automated AI processing and human review queues. It should be invoked whenever an upstream classifier, anomaly detector, or confidence threshold monitor decides that a case requires human judgment. The prompt's job is to transform raw operational signals—the triggering input, model state, relevant history, and diagnostic metadata—into a structured, self-contained review item that a human operator can evaluate without hunting for context across multiple systems. This means the implementation harness must ensure that all required inputs are available before the prompt fires, that the output conforms to the expected review schema, and that incomplete or malformed packages never reach the review queue.

Wire this prompt into your application as a post-escalation formatting step. When an upstream component raises an escalation flag, collect the required inputs: the original user input or triggering event, the model's internal state or reasoning trace, relevant conversation or session history, any tool outputs or retrieved evidence, and the diagnostic signals that triggered the escalation (e.g., anomaly scores, confidence values, policy boundary references). Pass these into the prompt template as structured variables. Validate the output against a strict schema before forwarding it to the review queue. Key validation checks include: presence of all required fields (triggering input, urgency classification, diagnostic summary), a non-empty evidence block, and a valid urgency enum value. If validation fails, retry once with a more explicit instruction appended to the prompt. If the retry also fails, log the raw inputs and the failed output for manual triage rather than silently dropping the escalation.

For model selection, prefer a model with strong instruction-following and structured output capabilities. The prompt requires precise formatting and consistent urgency classification, so models with weaker schema adherence may produce review items that break downstream queue routing. If your review queue system expects a specific JSON schema, enforce it with a post-processing validator and consider using function calling or structured output modes to guarantee field-level compliance. Log every packaged review item with a unique escalation ID, timestamp, and the model version used. This creates an audit trail that connects the original AI decision to the human review outcome. Avoid wiring this prompt directly into customer-facing surfaces without a review step—the packaged context may contain internal model state or diagnostic signals that are not appropriate for end-user visibility. Always route through an internal review queue first, and only expose sanitized summaries to external stakeholders if needed.