Session Boundary State Serialization Prompt

This prompt is designed for platform engineering teams building persistent chat products that must support pause-and-resume, session handoff, or long-term conversation archiving. Its primary job is to produce a complete, machine-readable state object at session end that captures all active context, pending items, unresolved questions, and policy constraints required to resume the conversation coherently at a later time. The ideal user is a backend engineer or AI infrastructure developer integrating this serialization step into a session lifecycle manager, a state storage database, or a conversation audit pipeline.

Use this prompt when your application needs a deterministic, structured snapshot of a conversation's boundary state that can be stored and restored without data loss. This is critical for chat systems where sessions span hours or days, where conversations may be transferred between agents or models, or where compliance requires a full record of what was known and pending at session close. The prompt expects a structured conversation log, the active system instructions, and any tool-use or policy state as inputs. It is not designed for real-time, turn-by-turn state tracking—use a Turn-Level State Change Audit Record Prompt for that. It is also not a substitute for a full conversation archive; it intentionally compresses the session into a resumable state object, not a verbatim transcript.

Before deploying this prompt, ensure you have defined a strict output schema for the serialized state object that your resume logic can parse. The prompt includes eval criteria for detecting missing state that would cause data loss on resume, such as dropped pending actions or unresolved user questions. Always pair this prompt with a validation harness that checks schema compliance and completeness before writing the state object to your storage layer. If the session involves regulated or high-stakes decisions, require human review of the serialized state before session termination to confirm no critical context was omitted.

This prompt template is designed to be invoked at the end of a conversation session—whether due to user inactivity, an explicit pause command, or a session timeout. Its job is to produce a single, structured JSON object that captures everything needed to resume the conversation later without data loss. The template uses square-bracket placeholders that you must replace with your application's specific state schema, active policies, and any domain-specific context that must survive the session boundary. Do not use this prompt for real-time, mid-conversation state tracking; it is optimized for the serialization moment when no further user input is expected before storage.

textCopy
You are a session state serialization agent. Your task is to produce a complete, structured JSON object representing the final state of this conversation session. This object will be stored and used later to resume the conversation exactly where it left off. Nothing important may be omitted.

## Input Context
- Full conversation history: [CONVERSATION_HISTORY]
- Active session metadata: [SESSION_METADATA]
- System policies and constraints: [SYSTEM_POLICIES]

## Required Output Schema
Produce a single JSON object conforming to this schema:
[OUTPUT_SCHEMA]

## State Categories to Capture
1. **Active Intents and Goals**: What the user was trying to accomplish. Include partially completed multi-step workflows.
2. **Pending Actions and Commitments**: Any tasks the assistant promised to complete, follow-ups owed to the user, or deferred work.
3. **Unresolved Questions**: User questions that were asked but not yet answered, including implicit questions inferred from context.
4. **Established Facts and Preferences**: User-provided information, decisions made, constraints acknowledged, and preferences stated during the session.
5. **Policy and Compliance State**: Which policies were triggered, any approvals granted, risk levels assessed, and regulatory constraints active.
6. **Tool and Retrieval State**: Pending tool calls, retrieved evidence still in context, and external system interactions that affect future turns.
7. **Conversation Phase and Tone**: The current phase of the interaction, the established tone, and any unresolved clarifications.

## Constraints
- [CONSTRAINTS]
- If any required field cannot be populated from the conversation, set its value to `null` and include a `"missing_reason"` string explaining why.
- Do not invent, assume, or hallucinate state that is not explicitly present in the conversation history.
- Preserve all user-provided data verbatim where applicable; do not paraphrase facts or preferences.
- Flag any state that appears contradictory or ambiguous with a `"needs_review": true` marker and a brief explanation.

## Examples of Good Serialization
[EXAMPLES]

## Risk Level
[RISK_LEVEL]

Now, produce the session state JSON object.

To adapt this template, start by defining your [OUTPUT_SCHEMA] as a strict JSON Schema or TypeScript interface. This schema is the contract between serialization and resumption—any field missing here is state that will be lost. The [CONSTRAINTS] placeholder should include domain-specific rules, such as PII redaction requirements, maximum field lengths for your storage system, or mandatory fields that must never be null. The [EXAMPLES] placeholder is critical for reliability: provide at least two few-shot examples showing correct serialization for a simple session and a complex session with pending actions and unresolved questions. If your application operates in a regulated domain, set [RISK_LEVEL] to "high" and add a constraint requiring a human review flag on any state that could affect compliance. After generating the state object, always validate it against your schema programmatically before storage—do not rely solely on the model's output conforming to the format.

This prompt is designed to be called at session termination events: explicit user logout, session timeout, or a pause_session API call from the application layer. The harness must capture the full conversation history, system instructions, and any active tool outputs as input context. The primary integration point is a pre-termination hook that invokes the LLM, validates the output against the expected state schema, and persists the serialized state object to durable storage before the session is torn down. The output is not user-facing; it is a machine-readable state artifact consumed by the resume workflow.

Schema enforcement is the critical path. Before storage, validate the LLM output against a strict JSON Schema that defines required fields: active_slots, pending_actions, unresolved_questions, policy_state, conversation_summary, and resume_context. Reject any output missing required fields or containing unexpected keys. Implement a retry loop with a maximum of 2 additional attempts, appending the schema violation errors to the retry prompt. If validation fails after 3 total attempts, log the failure, serialize a best-effort state object with an incomplete_flag: true marker, and alert the on-call channel. Do not silently drop state. For model choice, a model with strong JSON mode support and a large context window is required; GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro are appropriate defaults. Avoid models with weak instruction-following on long contexts, as missing a single pending action constitutes data loss.

Resume integration is the validation step. When a session resumes, the stored state object must be injected into the new session's system prompt or initial context. The harness should run a pre-resume validation check: does the stored state contain all required fields? Is the session_id correct? Has the state exceeded a configurable TTL (e.g., 7 days)? If the state is invalid or expired, fall back to a fresh session and notify the user that prior context was unavailable. Log every serialization and deserialization event with the session_id, state_version, model_used, validation_passed, and token_count for auditability. For high-compliance use cases, store the raw LLM response alongside the validated state object to support downstream audit review without re-running the prompt.