# How Seedance 2.0 Translates Treatments into Shot-List Continuity Workflows

> Learn how Seedance 2.0 transforms creative treatments into shot-list continuity workflows. It parses narratives into shot contracts, ensuring visual consistency with a ledger handoff.

- Repository: [Iamemily2050 /seedance-2.0](https://github.com/Emily2040/seedance-2.0)
- Tags: how-to-guide
- Published: 2026-08-03

---

**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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/references/shot-list-continuity.md).

## The Prompt Compilation Engine

The **Prompt Compiler**, implemented according to [`references/prompt-compiler.md`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/references/continuity-qc.md).

## Code Implementation Examples

### Shot Contract Structure

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

```json
{
  "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`](https://github.com/Emily2040/seedance-2.0/blob/main/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:

```python
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:

```python
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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/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.