Session Summary Policy Embedding Prompt

Use this prompt when your application restores conversation state from a compressed session summary and you need the assistant to respect the same behavioral policies, role boundaries, and refusal rules that were active during the original conversation. The core job is generating a summary-generation policy—a meta-instruction that tells the summarizer how to embed active constraints into the summary text itself, so that when a future turn begins with that summary as context, the assistant's guardrails are re-established without re-injecting the full system prompt. This is critical for multi-session products, context-window recovery, and handoffs between agents where policy continuity prevents trust failures.

Do not use this prompt if you can reliably re-inject the original system prompt at session start. If your architecture already prepends full system instructions to every request, embedding policies in summaries adds duplication and risks stale policy fragments conflicting with the authoritative system prompt. This prompt is also inappropriate for single-turn workflows, stateless APIs, or cases where the summary is only shown to humans. The value emerges when the summary is the context for the next model call and you cannot guarantee the original system prompt will be present. Before deploying, confirm that your eval harness measures policy fidelity in restored conversations—if you cannot measure whether the policy survived summarization, you cannot safely rely on this approach.

Start by cataloging which policies must survive summarization: refusal rules, capability boundaries, tone constraints, escalation triggers, and confidentiality limits. Then use this prompt to produce a policy document that your summarization step consumes. Wire the output into a validation step that checks summaries for policy representation before storing them. Avoid embedding volatile or session-specific instructions that should expire; this prompt is for stable behavioral contracts, not temporary context. If your policies change frequently, pair this with a policy version tag in the summary so restored sessions can detect mismatches.

This template produces a summary generation policy that forces the model to extract and embed active behavioral constraints—role boundaries, refusal rules, output moderation standards, and escalation thresholds—directly into the summary payload. The goal is not just to summarize what happened, but to preserve the policy envelope so that when a session is restored from summary, the assistant behaves within the same guardrails as the original conversation. Use this when your product supports session persistence, context restoration, or multi-session continuity where policy drift across restarts would create trust failures or compliance gaps.

textCopy
SYSTEM INSTRUCTION: You are a session summarizer operating under strict policy preservation rules.

Your task is to produce a JSON summary of the conversation below. The summary must include two required sections:

1. "conversation_summary": A concise factual summary of what occurred, including key decisions, unresolved questions, and user-stated preferences. Do not omit, embellish, or interpret beyond what is present in the transcript.

2. "active_policies": A structured object capturing every behavioral constraint that was active during this conversation. Extract policies from system instructions, explicit user directives, and assistant commitments. For each policy, include:
   - "policy_type": One of [ROLE_BOUNDARY, REFUSAL_RULE, OUTPUT_MODERATION, ESCALATION_THRESHOLD, TOOL_AUTHORIZATION, CONFIDENTIALITY_CONSTRAINT, TONE_VOICE, CAPABILITY_DECLARATION, COMPLIANCE_REQUIREMENT, CORRECTION_RULE, FALLBACK_BEHAVIOR, OTHER].
   - "policy_text": The exact policy language or a faithful paraphrase if the original is verbose.
   - "source": Where the policy originated [SYSTEM_PROMPT, USER_DIRECTIVE, ASSISTANT_COMMITMENT, TOOL_OUTPUT, INFERRED].
   - "priority": One of [IMMUTABLE, HIGH, MEDIUM, LOW] based on whether this policy should survive user corrections or context shifts.
   - "scope": One of [SESSION_ONLY, USER_PERSISTENT, GLOBAL] indicating how long this policy should remain active.

CONSTRAINTS:
- [CONVERSATION_TRANSCRIPT] is provided below. Summarize only what is present.
- If no policies are detectable, return an empty array for "active_policies". Do not invent policies.
- For IMMUTABLE policies (e.g., safety refusals, compliance rules), include a "reassertion_trigger" field indicating when this policy must be reasserted: [ON_RESTORE, EVERY_TURN, ON_TOPIC_CHANGE, ON_USER_CHALLENGE].
- Output valid JSON only. No commentary outside the JSON object.
- If the transcript contains [CONFIDENTIALITY_MARKERS], redact sensitive content from the summary and flag policies with "confidentiality_active": true.

[CONVERSATION_TRANSCRIPT]:
[INPUT]

[OUTPUT_SCHEMA]:
{
  "conversation_summary": "string",
  "active_policies": [
    {
      "policy_type": "string",
      "policy_text": "string",
      "source": "string",
      "priority": "string",
      "scope": "string",
      "reassertion_trigger": "string | null",
      "confidentiality_active": false
    }
  ],
  "summary_metadata": {
    "turn_count": "integer",
    "policies_detected": "integer",
    "immutable_policy_count": "integer",
    "generated_at": "ISO8601 timestamp"
  }
}

Adapt this template by adjusting the policy_type enum to match your organization's policy taxonomy. If your system uses a policy registry with unique identifiers, add a policy_id field and require the model to reference registered policies rather than duplicating text. For high-compliance environments, add a policy_evidence field that quotes the exact transcript segment justifying each extracted policy. When deploying across model families, test that the JSON schema is respected—Claude and GPT-4 handle nested objects reliably, but smaller models may flatten or omit fields. Always validate the output against the schema before storing the summary, and log policy extraction failures for review.

This prompt is designed to be called at session boundaries—when a conversation is being summarized for storage, handoff, or context window recovery. It should not be used as a standalone summarizer. Instead, it wraps your existing summary generation step with a policy embedding layer. The prompt expects three inputs: the active behavioral policies (role boundaries, refusal rules, tone constraints, tool authorization limits, and escalation thresholds), the raw conversation transcript, and a target summary schema. The output is a summary that preserves both the factual content of the conversation and the active policy constraints that must survive session restoration.

Wire this prompt into your application as a post-processing step after your primary summarization call. First, retrieve the active policy set from your policy store—this should be the same policy object used to construct the system prompt for the original conversation. Second, pass the transcript and policies to this prompt to generate a policy-augmented summary. Third, validate the output against your summary schema and run a policy fidelity check: extract the embedded policy statements from the summary and compare them against the original policy set using an LLM judge or deterministic diff. If the fidelity score drops below your threshold (we recommend 0.95 for production), retry with a higher temperature or escalate for human review. Log every summary generation with the policy version, fidelity score, and conversation ID for audit trails.

For high-risk domains—healthcare, legal, finance—add a human review step before the policy-embedded summary is committed to long-term storage. The review should confirm that no policy constraints were dropped, softened, or misrepresented during summarization. Implement retry logic with exponential backoff (3 attempts maximum) and circuit-break if the fidelity check fails consistently. Store the raw transcript alongside the summary for at least the retention period required by your compliance framework. Avoid using this prompt for conversations shorter than 5 turns, as the policy embedding overhead may distort the summary-to-content ratio. Test with adversarial transcripts that attempt to extract or override embedded policies during restoration to validate your hardening.