Unresolved Question Retention During Pruning Prompt

This prompt is designed for production AI engineers and platform teams building task-oriented chat assistants where the top failure mode is dropping unanswered user questions during context window pruning. The job-to-be-done is straightforward: before you discard conversation history to stay within a token budget, you must reliably detect every unresolved user question, pending commitment, or deferred task and ensure it survives the pruning process. This is not a general summarization prompt. It is a targeted safety net for the most common and costly context management mistake—silently forgetting what the user still needs.

Use this prompt when your system performs automated context window budgeting and turn pruning in multi-turn conversations. It is essential for customer support agents, copilots, and any assistant where users ask questions that span multiple turns and expect answers even after the original question has scrolled out of the active context window. The ideal user is an engineering lead or AI builder who already has a pruning pipeline in place and needs to add a pre-pruning detection layer. Required context includes the full conversation history slated for pruning, any existing session state, and a clear definition of what constitutes an 'unresolved' item in your domain. Do not use this prompt for single-turn Q&A, for sessions where you retain the entire history verbatim, or as a replacement for a structured dialogue state manager—it is a retention audit tool, not a state machine.

The prompt outputs an unresolved-item preservation list: a structured inventory of questions, commitments, and tasks that must be retained or summarized before pruning occurs. This list feeds directly into your pruning logic, acting as a mandatory inclusion filter. The primary constraint is that this prompt must run before any history is discarded; running it after pruning defeats its purpose. For high-stakes domains such as healthcare, legal, or financial services, the output should be logged as part of an audit trail, and a human review step should be available for edge cases where the model's confidence in its unresolved-item classification is low. The next step after implementing this prompt is to wire its output into your pruning decision prompt, ensuring that flagged items are either retained verbatim or compressed into a structured summary that preserves the user's original intent and any stated constraints.

The following prompt template is designed to be inserted into your pruning pipeline before conversation history is truncated. It instructs the model to scan the full conversation for unresolved questions, deferred tasks, and open commitments, then output a structured preservation list. This list should be injected into the pruned context or stored as session state so that critical follow-ups are not lost when older turns are removed.

textCopy
You are analyzing a conversation history before context pruning occurs. Your task is to identify all unresolved questions, pending commitments, and deferred tasks that must be preserved after older turns are removed.

## Conversation History
[CONVERSATION_HISTORY]

## Instructions
1. Scan every user turn for questions that have not received a complete answer.
2. Identify any promises or commitments the assistant made that have not yet been fulfilled (e.g., "I'll look into that," "Let me get back to you," "I'll check and confirm").
3. Detect tasks the user explicitly asked to defer or revisit later.
4. For each unresolved item, capture:
   - The original user question or request verbatim.
   - The turn number or timestamp where it appeared.
   - The current status: unanswered, partially answered, pending action, or deferred.
   - Any relevant context needed to resolve it (e.g., referenced entities, constraints the user stated).
5. Do not include questions that were fully answered or tasks that were explicitly completed or cancelled.
6. If no unresolved items exist, return an empty list.

## Output Schema
Return a JSON object with this exact structure:
{
  "unresolved_items": [
    {
      "item_id": "string",
      "source_turn": "integer or timestamp identifier",
      "question_or_commitment": "verbatim text from the conversation",
      "status": "unanswered | partially_answered | pending_action | deferred",
      "required_context": "brief summary of what the assistant needs to know to resolve this",
      "priority": "critical | high | medium | low"
    }
  ],
  "preservation_summary": "one-sentence summary of what must be carried forward"
}

## Constraints
- Preserve exact user wording in `question_or_commitment`. Do not paraphrase.
- Assign `critical` priority only to items where delay would cause harm, breach a commitment, or block the user's primary goal.
- If the conversation contains [RISK_LEVEL] content, flag any unresolved items involving safety, compliance, or regulated topics with `critical` priority.
- Limit `required_context` to 2 sentences maximum.

To adapt this template, replace [CONVERSATION_HISTORY] with your full or windowed conversation turns, formatted as speaker-labeled messages. The [RISK_LEVEL] placeholder should be set to a value like high, medium, or low based on your domain's sensitivity—this controls whether safety-related items are automatically escalated to critical priority. After running this prompt, store the output JSON and inject the preservation_summary plus any critical or high priority items into your pruned context prefix. Validate that the output conforms to the schema before trusting it in production; a malformed preservation list is worse than no list because it creates a false sense of security.

This prompt is designed to run as a pre-processing step before a conversation history pruning operation. It should be invoked when the context window budget is exceeded and a pruning decision is required. The prompt takes the full conversation history and a list of candidate turns marked for removal, and it returns a preservation list of unresolved items that must be retained. The output is not the pruned history itself, but a structured artifact that the application layer uses to modify the pruning plan before execution.

To integrate this into an application, implement a two-phase pruning pipeline. In Phase 1, run your standard pruning decision prompt to classify turns as retain, summarize, or discard. In Phase 2, before executing the pruning, pass the full conversation and the proposed discard list into this Unresolved Question Retention prompt. The prompt will return a JSON array of unresolved items—each with a question_text, source_turn_id, status, and preservation_action. Your application must then reconcile this preservation list against the proposed pruning plan: any turn referenced in the preservation list must be reclassified from discard to retain or summarize, and any extracted question must be injected into the session summary or carried forward as active state. Validate the output against a strict JSON schema before applying it. If the model returns malformed JSON, retry once with a stronger format constraint appended to the prompt. If validation fails twice, log the failure, retain all turns flagged by the pruning decision as a safety measure, and alert the ops team.

For model choice, use a model with strong instruction-following and JSON output capabilities, such as GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro. Avoid smaller or older models that may miss implicit questions or produce inconsistent JSON under complex conversation structures. Set temperature to 0 or a very low value (0.1) to maximize deterministic extraction. If your application uses RAG, ensure that retrieved evidence chunks are included in the conversation context passed to this prompt, as unresolved questions may reference or depend on retrieved facts. Log every preservation list output alongside the pruning decision for auditability. In high-stakes domains such as healthcare or legal support, route the preservation list to a human reviewer before pruning is executed, especially when the status field contains unresolved or needs_clarification.

Common failure modes to monitor: the model may hallucinate questions that were never asked, miss questions embedded in multi-paragraph user turns, or fail to recognize that a question was implicitly answered by a tool output rather than an assistant text response. To guard against these, implement a post-processing check that verifies each extracted question's source_turn_id exists in the original conversation. Track the question answer rate metric after pruning—if it drops below your baseline, increase the retry budget or add few-shot examples of borderline cases to the prompt. Do not use this prompt in isolation; it is a safety net for your pruning logic, not a replacement for a well-tuned pruning decision prompt.