How Seedance 2.0 Translates Treatments into Shot-List Continuity Workflows

Seedance 2.0 converts high-level creative treatments into production-ready shot lists by parsing narrative spines into discrete shot contracts with continuity locks, then maintaining visual consistency through a ledger-based handoff system that anchors each generated clip to its predecessor.

Seedance 2.0 treats the treatment—the high-level creative brief—as the entry point for a fully-featured AI video production pipeline. According to the Emily2040/seedance-2.0 repository, this shot-list continuity workflow extracts the narrative spine, builds executable shot contracts, and stitches together a continuity ledger that guarantees every generated clip respects the visual and narrative constraints of previous shots.

From Treatment to Story Spine

The pipeline begins by parsing the user-provided treatment into a hierarchical story outline comprising acts, scenes, and beats. This structure becomes the project-level spine stored in the Project State Capsule, as defined in references/sequence-project-state.md.

The story spine serves as the authoritative blueprint that drives all downstream decisions. It maintains the narrative lineage and contextual scope required to ensure that individual shots align with the broader creative vision.

Building Shot Contracts and the Continuity Ledger

Once the spine is established, the system decomposes it into concrete shot contracts. Each contract, specified in references/shot-list-continuity.md, defines:

• clip_id and scene_id for lineage tracking
• Camera intent, lighting, and audio specifications
• Continuity locks (e.g., wardrobe, props, eyeline) that must persist across cuts
• Allowed changes that the generation model may introduce

Simultaneously, the system generates a continuity ledger entry for every shot. This ledger records the accepted last frame (the "anchor") and any allowed changes, creating a persistent state store that prevents frame-to-frame drift. The ledger schema is documented in references/shot-list-continuity.md.

The Prompt Compilation Engine

The Prompt Compiler, implemented according to references/prompt-compiler.md, transforms shot contracts into model-ready instructions. It operates by injecting continuity ledger values—specifically the @Video1 source clip placeholder—while stripping any language that would overwrite locked elements.

The compiler ensures that generated prompts only describe the intended change (such as camera movement or ambient sound shifts) while explicitly preserving anchored states like wardrobe and character positioning. This approach mimics the role of a traditional script supervisor by encoding continuity constraints directly into the generation prompt.

Generation, Observation, and Handoff

When the compiled prompt is sent to the generation model, the resulting clip undergoes observation. The observed end state is stored back into the continuity ledger as the new "accepted last frame," as implemented in scripts/continuity_chain_check.py.

The next shot's contract inherits both the continuity locks and the accepted last frame from the previous ledger entry, ensuring seamless visual and narrative flow. This handoff protocol, detailed in references/continuation-handoff.md, allows the pipeline to generate long sequences without collapsing the entire story into a single prompt.

Before advancing, a continuity-QC pass validates that the new clip honors all locks and introduces no drift, as specified in references/continuity-qc.md.

Code Implementation Examples

Shot Contract Structure

The JSON schema for shot contracts defines the explicit constraints that govern generation:

{
  "clip_id": "clip_02",
  "scene_id": "scene_01",
  "sequence_index": 2,
  "parent_clip_id": "clip_01",
  "continuity_locks": ["wardrobe", "eyeline", "product_tag"],
  "allowed_changes": ["camera_move", "ambient_sound"],
  "planned_start_state": {
    "character": "traveler",
    "wardrobe": "charcoal coat",
    "position": "two steps from rear door",
    "camera": "lateral pan"
  },
  "planned_end_state": {
    "character": "traveler",
    "position": "inside rear seat",
    "door_state": "closed"
  }
}

This structure is validated against schemas/project-state.schema.json and stored within the Project State Capsule.

Prompt Compilation Logic

The Python implementation pulls anchor frames and continuity constraints to build generation-ready prompts:

from seedance.prompt_compiler import compile_prompt

contract = load_json('clip_02_contract.json')
ledger = load_ledger('continuity_ledger.json')

prompt = compile_prompt(
    contract=contract,
    source_clip=ledger[contract["parent_clip_id"]]["accepted_last_frame"],
    continuity_locks=contract["continuity_locks"],
    allowed_changes=contract["allowed_changes"]
)

print(prompt)

The compile_prompt function references ledger[contract["parent_clip_id"]]["accepted_last_frame"] to establish the visual anchor for the next shot.

Ledger State Management

After generation, the system updates the continuity ledger to persist the new anchor state:

def update_ledger(clip_id, observed_state):
    ledger[clip_id] = {
        "accepted_last_frame": observed_state["final_frame"],
        "continuity_anchors": observed_state["anchors"]
    }
    save_ledger(ledger)

This logic, reflected in scripts/continuity_chain_check.py, ensures that subsequent shots inherit the correct visual baseline.

Summary

• Seedance 2.0 converts treatments into structured shot lists through a seven-stage pipeline that bridges creative briefs and technical execution.
• Shot contracts in references/shot-list-continuity.md encode continuity locks and allowed changes, preventing visual drift across generated clips.
• The continuity ledger stores accepted last frames as anchors, enabling stateful handoffs between shots without requiring full sequence regeneration.
• The Prompt Compiler injects ledger values into generation prompts, ensuring that only intended changes are rendered while locked elements persist.
• Continuity-QC validation in references/continuity-qc.md verifies that each new clip honors the constraints of the previous frame before pipeline advancement.

Frequently Asked Questions

What is a continuity lock in Seedance 2.0?

A continuity lock is a constraint defined in a shot contract that specifies elements which must remain visually consistent across consecutive clips. According to references/shot-list-continuity.md, common locks include wardrobe, eyeline, prop positions, and product tags, which the Prompt Compiler protects from alteration during generation.

How does the continuity ledger prevent visual drift?

The continuity ledger records the accepted last frame of each generated clip as an anchor state. When compiling the next shot, the system references this anchor via ledger[parent_clip_id]["accepted_last_frame"], ensuring that the subsequent generation starts from the exact visual endpoint of its predecessor rather than inferring state from text descriptions alone.

What role does the Project State Capsule play in the workflow?

The Project State Capsule, defined in references/sequence-project-state.md, serves as the central store for the hierarchical story spine and all shot contracts. It maintains the parent_clip_id relationships and sequence indices that enable the continuity handoff logic to traverse the shot list correctly.

How does the Prompt Compiler handle source clips?

The Prompt Compiler retrieves the accepted last frame from the continuity ledger and inserts it as @Video1 into the generation prompt. As implemented in the compilation logic, it strips any descriptive language that would contradict the continuity locks, ensuring the model receives explicit visual anchoring rather than relying on textual descriptions of persistent elements.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}