Citation Numbering Sequence Repair Prompt Template

This prompt is for product teams and developers who operate RAG systems, documentation generators, or any AI feature that produces inline numeric citations (e.g., [1], [2], [3]) alongside a reference list. The core job-to-be-done is repairing a broken citation sequence after a model has inserted, deleted, or reordered claims, leaving the numbering non-sequential, duplicated, or mismatched between the body text and the reference list. The ideal user is an engineer integrating this repair step into a post-generation validation pipeline, where the output must be machine-readable and the citation integrity is a hard requirement for downstream consumers or compliance reviewers.

Use this prompt when you have a complete answer text and a complete reference list, but the numeric labels are out of sync. Typical failure signals include: a reference list with entries numbered 1 through 5 but inline citations that jump from [1] to [4]; duplicate citation numbers pointing to different sources; or a reference entry that is never cited in the body. This prompt is designed to be run as a deterministic repair step, not as a general-purpose answer generator. It assumes the underlying claims and source mappings are already correct and only the numbering sequence needs repair. Do not use this prompt when the citations themselves are hallucinated, when the reference list is incomplete, or when the mapping between claims and sources is broken—those failures require different repair playbooks such as Hallucinated Citation Removal or Citation-to-Evidence Alignment.

Before invoking this prompt, ensure you have a validated reference list where each entry is a distinct source and a body text where citation markers are the only thing that needs fixing. The prompt works best when the input is a single, complete artifact rather than a streaming fragment. If your system allows users to edit the generated text between generation and repair, you must re-run the repair step after any edit that adds or removes citations. For high-stakes domains such as legal, clinical, or financial documentation, always route the repaired output through a human review step and log the before/after citation map for auditability. The next section provides the copy-ready prompt template you can adapt into your repair harness.

This prompt template is designed to be dropped into a post-generation repair step. It takes a text body with inline citation markers and a reference list, then rewrites both so that numbering is consecutive, consistent, and free of gaps. The template uses square-bracket placeholders for all variable inputs, allowing you to parameterize it in your application code before sending it to the model.

textCopy
You are a citation numbering repair system. Your job is to fix broken, skipped, or non-sequential numeric citation numbering in the provided text.

## INPUT
[BODY_WITH_CITATIONS]

[REFERENCE_LIST]

## CONSTRAINTS
[CONSTRAINTS]

## INSTRUCTIONS
1. Identify every inline citation marker in the body text. Markers may appear as [1], [2,3], [4-6], or similar numeric patterns.
2. Identify every reference entry in the reference list. Each entry should have a unique identifier (number, tag, or key).
3. Map each inline citation to its correct reference entry based on content matching, not current numbering.
4. Reassign consecutive numbers starting from 1 to all cited references in the order they first appear in the body text.
5. Rewrite the body text with corrected inline citation numbers.
6. Rewrite the reference list with corrected numbering, preserving all reference content and metadata.
7. If a reference is listed but never cited, append it to the end of the reference list with a note: [uncited].
8. If an inline citation points to a reference that does not exist in the list, flag it with [missing-reference] and do not assign it a number.
9. Do not alter any text except citation numbers and reference list ordering/numbering.
10. Preserve all formatting, whitespace, and non-citation content exactly.

## OUTPUT_SCHEMA
Return a JSON object with this exact structure:
{
  "repaired_body": "string (body text with corrected citation numbers)",
  "repaired_reference_list": "string (reference list with corrected numbering)",
  "citation_map": [
    {
      "original_number": "string or number",
      "new_number": "number",
      "reference_key": "string",
      "status": "repaired | uncited | missing-reference"
    }
  ],
  "warnings": ["string (any issues encountered)"]
}

## EXAMPLES
[EXAMPLES]

## RISK_LEVEL
[RISK_LEVEL]

To adapt this template, replace each placeholder with values from your application context. [BODY_WITH_CITATIONS] should contain the full text with inline citation markers. [REFERENCE_LIST] should contain the complete reference section. [CONSTRAINTS] can specify additional rules such as a maximum citation number, a required citation style, or domain-specific formatting requirements. [EXAMPLES] should include one or two worked examples showing the correct repair behavior for your citation format. [RISK_LEVEL] should be set to high if the output will be shown to users without human review, triggering additional validation and confidence checks before the repaired text is released.

After copying this template, wire it into a post-generation pipeline that runs after your primary model produces a response. Validate the output JSON against the schema before accepting it. If the warnings array contains entries or if any citation has a missing-reference status, route the output for human review or trigger a fallback repair strategy. For high-risk domains such as legal, medical, or financial content, always require human approval on repaired citations before publication.

The Citation Numbering Sequence Repair prompt is designed to be called as a post-generation repair step, not as the primary generation prompt. Wire it into your application after the initial model response is received and before the output is stored or displayed to the user. The typical integration point is inside a validation pipeline: your application receives a model-generated text with inline numeric citations and a reference list, runs a structural validator to detect numbering gaps, duplicates, or mismatches, and if validation fails, invokes this repair prompt with the original text and the validation error details. This keeps the repair prompt focused on a single task and avoids running it unnecessarily on outputs that are already correct.

For production implementation, wrap the prompt call in a retry loop with a maximum of 2-3 attempts. On each attempt, pass the previous repair output and any new validation errors back into the [PREVIOUS_ATTEMPT] and [VALIDATION_ERRORS] placeholders. If the output still fails validation after the retry budget is exhausted, escalate to a human review queue rather than silently accepting broken citations. Log every repair attempt with the input text hash, validation error counts, repair duration, and final pass/fail status. This audit trail is essential for debugging model drift and for compliance workflows where citation integrity is a hard requirement. Use structured logging fields: citation_repair_attempt, input_citation_count, output_citation_count, gaps_found, gaps_resolved, validation_passed.

Model choice matters here. This task requires precise instruction following and structured output adherence, not creative generation. Use a model with strong JSON mode or structured output support, such as GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro, configured with a strict output schema that enforces the repaired text and the repair audit log as separate fields. Avoid models that tend to paraphrase or rewrite surrounding content—the repair must preserve all non-citation text exactly. Set temperature to 0 or near-zero to minimize variability. If your application uses streaming, buffer the complete output before running repair; partial streams will produce false-positive validation failures and waste repair attempts.

The repair prompt's output should be validated programmatically before acceptance. Implement a post-repair validator that checks: (1) every inline citation number has a corresponding entry in the reference list, (2) reference list numbering is consecutive starting from 1 with no gaps, (3) no citation numbers appear in the reference list that aren't used inline, and (4) the non-citation text content is byte-identical to the original input except for the repaired citation numbers. This last check prevents the model from silently rewriting content during repair. If any check fails, feed the specific failure details into the next retry attempt's [VALIDATION_ERRORS] placeholder. For high-stakes domains like legal or medical documentation, always require human review of the repair audit log before the output is published, even if all automated validations pass.