Seedance 2.0 Continuation Handoff and Observed State Handling: A Complete Guide

Seedance 2.0 continuation handoff operates as a stateful observation‑first workflow where every new clip generation must be grounded in an explicitly observed end state from an accepted parent clip, never fabricated.

The continuation handoff system in Seedance 2.0 ensures narrative consistency across multi‑clip sequences by treating each generation—whether an extend, next‑shot, bridge, repair‑tail, or re‑anchor—as a strict handoff from verified footage. This article explains how observed state handling prevents drift, the source gate protects against hallucination, and the integration between handoff records, project state, and prompt compilation.

The Source Gate: Foundations of Observed State Handling

Before any continuation prompt can be constructed, Seedance 2.0 enforces a source gate that blocks progression until all required context is present. This gate, defined in references/continuation-handoff.md, enumerates nine mandatory items:

• Project ID and current Clip ID — identifies the story and active clip
• Parent Clip ID — links the new clip to its predecessor
• scene_id and scene‑boundary flag — determines seamless versus cut transitions
• Accepted source clip or final frame — grounds the prompt in real, approved output
• Observed end state — the actual visual/audio condition after agent inspection
• Next clip's felt_intent — drives creative direction
• Completed beats and reserved future beats — prevents narrative repetition
• Continuity locks and exact reference tags — preserves precise object placement
• Active surface profile — selects generation parameters (photorealistic, illustration, etc.)

If any item is missing, the agent prompts the user for the missing media or a visible‑end description. The system never invents missing state. This protection is documented in the Source Gate section of the handoff reference.

Observation Fast Path: How the Agent Becomes State Sensor

When the client can render attached media, the agent activates the observation fast path—a direct inspection workflow that minimizes user burden while maximizing accuracy:

Final‑Frame Attachment

The agent reads pose, screen position, wardrobe, props, environment, lighting, and framing directly from the still. Because a still cannot convey motion or sound, the agent asks at most three targeted follow‑up questions:

1. Open motion (what is moving and how?)
2. Camera phase (tracking, static, zoom, etc.)
3. Audio phase (dialogue, music, ambient sound)

This is described in the Observation Fast Path section.

Full‑Clip Attachment

With complete footage, the agent automatically extracts motion, camera, and audio—no follow‑up required.

No Attachment Fallback

When no media is attached, the agent:

• Requests a user‑provided description
• Suggests running the extraction script first: python scripts/extract_last_frame.py

If the client cannot inspect attachments, the observation is recorded as low‑confidence (observation_confidence: low, requires_user_confirmation: true). This prevents corrupted canonical state.

Handoff Record Structure

The handoff record captures both frame‑readable and frame‑blind observations in a structured format:

• Observed start and end states
• Open motion vector, camera phase, screen direction
• Character pose and gaze, prop ownership and condition
• Location, lighting, ambience, dialogue, music, SFX
• Confidence level and explicit uncertainties

These fields populate the Project‑State Capsule—a concise JSON model stored per project. The Handoff Record section defines the complete schema.

Continuation Types: Seamless Versus Intentional

The handoff determines which of five continuation types applies:

Type	Applies When	Key Rule
seamless_continuation	Same shot, geography, open motion; inside same scene	Only legal inside a scene; otherwise use intentional_next_shot
intentional_next_shot	Scene boundary or editorial cut	Opens from canonical references; resets extension_depth to 0
bridge_between_known_states	Connect known start to known final state	—
repair_tail	Fix final seconds of failed parent clip	—
reanchor_after_drift	Reset chain when depth or drift destabilizes continuation	—

The Seamless Versus Next Shot section contains the full decision logic.

Beats, Locks, and Tags: Exclusion Rules

Every continuation prompt must exclude completed beats (actions already performed) and reserved future beats (actions scheduled for later). This prevents narrative regression.

Continuity locks and exact reference tags (@Image1, [Video 1], etc.) are preserved verbatim for downstream rendering pipelines. The handoff reference emphasizes this exclusion on lines 68–71, with additional detail in the Exact Reference Tags section.

Acceptance Rule and Canonical State

Only accepted observed state overwrites planned state. Rejected footage never becomes canon, and every continuation prompt must reference the last accepted observation. This Acceptance Rule is the primary defense against drift across long generation chains.

System Integration: Components and Workflow

Component	Role in Continuation Handoff
Skill: seedance‑continuation	Loads handoff reference, project‑state capsule, prompt compiler, and continuity‑QC references; orchestrates handoff flow per [skills/seedance-continuation/SKILL.md](https://github.com/Emily2040/seedance-2.0/blob/main/skills/seedance-continuation/SKILL.md)
Prompt Compiler	Uses observed end state, felt_intent, and beat exclusions to build prompts per [references/prompt-compiler.md](https://github.com/Emily2040/seedance-2.0/blob/main/references/prompt-compiler.md)
Project‑State Capsule	Stores concise JSON of scene, clip lineage, and observed states; regenerated after each accepted take per [docs/RELEASE_v6.6.0.md](https://github.com/Emily2040/seedance-2.0/blob/main/docs/RELEASE_v6.6.0.md)
Continuity‑QC	Validates continuity locks, beat exclusions, and reference tags before acceptance per [references/continuity-qc.md](https://github.com/Emily2040/seedance-2.0/blob/main/references/continuity-qc.md)

These components form a closed loop: observe → record → compile → generate → validate → accept → repeat.

Practical Workflow: Code Examples

Extract Final Frame and Observation Record

# Generate image reference and observation skeleton from accepted take

python scripts/extract_last_frame.py clip_01_take.mp4 --emit-record > obs_record.json

This implements the Observation Fast Path.

Update Project‑State Capsule

# Merge observation into canonical project state (updates project-state.json in place)

python scripts/update_project_state.py --record obs_record.json

This writes the Handoff Record to the Project‑State Capsule.

Compile Continuation Prompt

# Build prompt respecting continuation type, intent, and beat exclusions

python scripts/compile_prompt.py \
    --clip-id clip_02 \
    --type seamless_continuation \
    --intent "The traveler should feel suspense as the door swings open" \
    --output prompt_clip_02.txt

This invokes the Prompt Compiler with felt_intent and beat exclusions.

Trigger Continuation Skill

# Submit to generative model with automatic handoff reference loading

seedance-cli ask --skill seedance-continuation --prompt-file prompt_clip_02.txt

The seedance‑continuation skill automatically loads [ref:continuation-handoff] and enforces all handoff rules.

Key Implementation Files

File	Purpose
references/continuation-handoff.md	Canonical handoff process, source gate, observation fast path, record format
skills/seedance-continuation/SKILL.md	Skill orchestration and reference loading
references/sequence-project-state.md	Project‑State Capsule JSON structure
scripts/extract_last_frame.py	Frame extraction and observation skeleton generation
scripts/update_project_state.py	Observation record merge into project state
scripts/compile_prompt.py	Prompt compilation with intent and exclusion handling
docs/RELEASE_v6.6.0.md	Observation Fast Path and state lifecycle release notes

Summary

• Source Gate blocks continuation until all required context—including explicitly observed state—is present
• Observation Fast Path minimizes user input when media is attachable, falls back to low‑confidence user description when not
• Handoff Record captures comprehensive state in a structured format for the Project‑State Capsule
• Five continuation types (seamless_continuation, intentional_next_shot, bridge_between_known_states, repair_tail, reanchor_after_drift) determine generation strategy
• Beat exclusion and continuity locks prevent narrative regression and preserve precise references
• Acceptance Rule ensures only verified state becomes canonical, preventing drift
• Closed‑loop integration between handoff reference, state capsule, prompt compiler, and QC guarantees observed‑state fidelity across arbitrary clip chains

Frequently Asked Questions

What happens if the source gate detects missing state?

The agent prompts the user for the missing media (accepted clip or final frame) or requests a visible‑end description. It never proceeds with fabricated state. This halt‑and‑request behavior is the core protection of the source gate mechanism.

How does Seedance 2.0 handle low‑confidence observations?

When media cannot be inspected, the agent records the user‑provided description with observation_confidence: low and requires_user_confirmation: true. This flags the record for human verification before it enters the canonical project state, preventing corruption from hallucinated details.

What is the difference between seamless continuation and intentional next shot?

Seamless continuation (seamless_continuation) applies within the same scene with matching geography and open motion, allowing uninterrupted flow. Intentional next shot (intentional_next_shot) applies at scene boundaries or editorial cuts, opens from canonical references rather than direct observation, and resets extension_depth to 0. Using seamless continuation across scene boundaries violates the handoff rules.

Why must completed and reserved beats be excluded from continuation prompts?

Excluding completed beats prevents the next clip from repeating actions already performed. Excluding reserved future beats prevents premature execution of actions scheduled for later clips. Together they maintain narrative progression integrity and prevent temporal confusion in long sequences.

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