# Continuity-First Filmmaking Plan

Status: writing slice implemented 2026-09-05 (see *Decisions and scope*); the generation-side sections below are a research record, not adopted  
Date: 2026-09-05

## Decision

The plugin should stop treating a film as a list of attractive shot prompts and start treating it as a stateful dramatic sequence.

Five product rules follow:

1. Preserve story intent and state from scene writing through the final prompt.
2. Design shots first, then partition them into generation runs as a separate optimization.
3. Use the fewest runs that fit a **model-tested coherence envelope**, not simply the model's maximum duration.
4. Treat every cross-generation boundary as a typed contract carrying narrative, physical, visual, performance, and audio state.
5. Approve footage in an assembled sequence and commit what the accepted footage actually shows.

This is more important than adding more transition vocabulary. A transition can disguise a cut; it cannot create an objective, causal consequence, preserved prop state, or continuous performance that was never specified.

## Diagnosis

The current pipeline is strongest after shot design and weakest before it:

```text
CURRENT
brief -> logline -> 3–5 beats -> thin scene prose
      -> rich breakdown -> reduced shotlist record
      -> newly invented prompt action -> independent clips
      -> join repair

TARGET
brief -> story canon/state -> scene contracts -> scene blocking
      -> shot contracts -> run packing -> seam contracts
      -> model-specific prompt/reference compilation -> candidates
      -> assembled sequence review -> approve/repair
      -> commit observed state
```

### What is failing now

| Symptom | Current root cause | Product consequence |
|---|---|---|
| Opening scenes feel generic or inert | The no-script path moves quickly from logline/beats to 2–3 action sentences; no opening-readability or dramatic-action gate exists | Prompt assembly must invent behavior late, often producing walking, looking, posing, or atmosphere without a playable task |
| Approved directing intent disappears | Breakdown can contain goal, owner, task verb, dramaturgy, blocking, and acting, but the shotlist contract reduces it to a short action plus visual settings | The generator does not receive the reasoning the user approved |
| Adjacent scenes feel like unrelated clips | `film.json` has production metadata and limited physical `endState`, but no canonical goals, beliefs, knowledge, relationships, emotional residue, story questions, or causal deltas | A later scene can look correct while behaving as if earlier scenes never happened |
| A cross-run continuation resets | The next run inherits a planned text description, not a verified account of the accepted clip's real terminal state | Pose, motion, gaze, prop placement, costume condition, light, and performance can all jump |
| “Clean breaks” still feel episodic | Existing seam rules focus on visual cut geometry and may intentionally align nothing | A clean visual discontinuity is mistaken for story continuity |
| Cross-scene runs leak or muddle details | Runs may span scenes, while the prompt grammar supplies one scene context/location map and no formal scene-reset block | Cast, room, wardrobe, atmosphere, and lighting can bleed between scenes |
| Starts contradict each other | One rule asks for a quiet wide opening; others require no empty establishing beat and action already underway | The model receives incompatible priorities exactly where clarity matters most |
| Long runs sometimes omit actions | Packing is dominated by seconds and hard limits, not event complexity or reference load | The model gains shared context but loses instruction fidelity |
| Problems are found after spending credits | The pilot tests one run, end-frame chaining is optional, and joins are often reviewed only when suspected | The actual failure mode—two independent generations meeting—is not tested early |

These are instruction and data-flow problems, not evidence that the agent merely “forgot” the transition rules.

## What the research supports

### Strong findings

- Structured planning and evolving story state are better foundations than generating scenes independently. Re3 combines a plan, current story state, reranking, and factual repair; DOC moves additional planning work into a hierarchical outline and reports higher human-rated plot coherence than prior systems. [Re3](https://arxiv.org/abs/2210.06774), [DOC](https://aclanthology.org/2023.acl-long.190/)
- Rich narrative representations track more than appearance. MovieGraphs models character attributes, relationships, interactions, and reasons; STAGE tests screenplay understanding through a shared evolving world representation. [MovieGraphs](https://arxiv.org/abs/1712.06761), [STAGE](https://arxiv.org/abs/2601.08510)
- Professional continuity work uses a structured record for story day, cast, action, wardrobe, makeup, props, dialogue, emotion, composition, camera movement, direction, eyelines, settings, and reference stills. [ScreenSkills script-supervisor standard](https://www.screenskills.com/skills-checklists/scripted-film-and-tv/script-supervisor-department/script-supervisor-skills/)
- Action continuity is a powerful bridge across edits; post-cut motion and continuous audio also materially affect whether viewers perceive a cut as disruptive. This supports action and audio handoffs, but not a universal edit formula. [Magliano and Zacks](https://pmc.ncbi.nlm.nih.gov/articles/PMC3208769/), [Smith and Martin-Portugues Santacreu](https://doi.org/10.1080/15213269.2016.1160789)
- Explicit initial and final states help define a transition, yet current video generators still struggle to execute them. In TC-Bench, most tested generators completed less than 20% of specified compositional changes. [TC-Bench](https://aclanthology.org/2025.findings-acl.241/)
- Seconds alone do not measure prompt difficulty. StoryEval tested 2–4-event stories across 11 models; none exceeded a 50% average event-completion rate. [StoryEval](https://openaccess.thecvf.com/content/CVPR2025/html/Wang_Is_Your_World_Simulator_a_Good_Story_Presenter_A_Consecutive_CVPR_2025_paper.html)
- Shared generation context can preserve characters across multiple shots, but long samples can also develop incoherence and incorrect object-state changes. [OpenAI's video world-simulator report](https://openai.com/index/video-generation-models-as-world-simulators/)
- Last-frame chaining is not enough for long-form continuity. StreamingT2V combines recent-frame features for short-term transitions with long-term appearance conditioning; repeated dependence on only the preceding final frame can stagnate or degrade. [StreamingT2V](https://openaccess.thecvf.com/content/CVPR2025/papers/Henschel_StreamingT2V_Consistent_Dynamic_and_Extendable_Long_Video_Generation_from_Text_CVPR_2025_paper.pdf)
- A large undifferentiated prompt is not the same as coherent context. Long Context Tuning reports that concatenating all shot descriptions can impede semantic separation, while independently animating sparse keyframes does not guarantee reappearance consistency. [Long Context Tuning](https://openaccess.thecvf.com/content/ICCV2025/html/Guo_Long_Context_Tuning_for_Video_Generation_ICCV_2025_paper.html)

### What the supplied report gets right

Adopt these ideas:

- a compact Scene Contract before screenplay prose;
- immutable and mutable story state;
- explicit input state, beat progression, turn, output delta, and handoff;
- typed contradiction findings and minimal repair;
- reference locking, boundary frames, and early assembled review;
- automated checking as assistance rather than final authority.

### What should not be followed blindly

- A Scene Contract is a well-supported design hypothesis, not a clinically proven cure for generated-film continuity.
- “One dominant action per shot” must not become “one generation per shot.” Shot design and generation partitioning are separate passes.
- Not every lyrical, observational, montage, dream, or title scene needs a conventional objective–obstacle–turn. Exceptions must be deliberate and typed.
- A mandatory establishing wide, the 180-degree rule, or a fixed match-action frame overlap should be warnings and creative choices, not universal rejection gates.
- Last-frame conditioning is one input, not the whole memory system.
- More agents do not inherently produce better continuity. Clear ownership, state provenance, and approval rules matter first.
- Rights and provenance are important, but they are a separate workstream from this continuity MVP.

## Target architecture

### 1. Canonical production memory

Add a versioned ledger to `film.json` with two layers.

**Immutable or deliberately revised canon**

- character identity and stable appearance;
- location identity and invariant geometry;
- story-world rules;
- visual language and format;
- fixed backstory and relationships.

**Mutable state on a timeline**

- time, location, present characters, and spatial geography;
- goal, tactic, belief, knowledge, secret, and audience knowledge;
- relationship status and emotional residue;
- pose, gaze, movement direction, and screen side;
- wardrobe, hair, makeup, wetness, dirt, damage, and injuries;
- prop owner, holder, hand, location, orientation, and condition;
- environment changes, lighting source, exposure intent, and atmosphere;
- active audio bed and unresolved story questions.

Every value needs `source`, `status`, and validity:

```json
{
  "path": "characters.mother.money",
  "value": 0,
  "status": "observed_approved",
  "source": { "runId": "run-01", "timecode": "00:14.8" },
  "validFrom": "sc01.beat03",
  "confidence": 0.96
}
```

Allowed statuses should include `canon`, `planned`, `provisional`, `observed`, `observed_approved`, `superseded`, and `intentional_exception`. This resolves the supplied report's conflict between “never invent facts” and the practical need to introduce new ones.

### 2. Scene Contract

Create the contract before writing polished scene prose. Keep it short enough to inspect.

```json
{
  "sceneId": "sc01",
  "mode": "dramatic",
  "purpose": "Elena discovers cinema through her mother's sacrifice",
  "pov": "young Elena",
  "entryStateRefs": ["state.storyStart", "location.oldCinema"],
  "objective": "Mother gets Elena into the screening",
  "obstacle": "She has only enough money for the tickets",
  "stakes": "The outing fails and Elena sees the family's scarcity",
  "whyNow": "The screening is about to begin",
  "beats": [
    {
      "id": "b1",
      "startState": "They approach the booth; mother hides her worry",
      "action": "The price appears; mother checks the coins without stopping Elena",
      "reaction": "Elena pulls toward the glowing lobby, unaware",
      "resultState": "Mother must choose whether to spend everything"
    }
  ],
  "turn": "Mother gives Elena the ticket and has no coins left",
  "stateDelta": ["mother.money: last_coins -> 0", "elena.hasTicket: false -> true"],
  "nextTrigger": "The ticket admits Elena to the image that changes her life",
  "exceptions": [],
  "approval": "pending"
}
```

Scene modes should include `dramatic`, `observational`, `montage`, `dream`, `title`, and `intentional_discontinuity`. Each has an appropriate rubric; the system should not force fake conflict into a montage.

### 3. Opening-readability gate

The opening of the film and every newly oriented scene must answer, through visible behavior rather than exposition:

- Who owns our attention?
- Where are they in usable spatial terms?
- What are they doing right now?
- What do they want or protect?
- What pressure has begun?

This does **not** require a static wide. Use a motivated orientation beat with live behavior. The first action should have a readable before, execution, and consequence. Reject placeholders such as “walks cinematically,” “looks emotional,” or “takes in the room” unless the visible task and changing state are also specified.

The opening gate passes when a reviewer can describe the subject, task, spatial anchor, and immediate pressure from the first few seconds without reading the synopsis.

### 4. Shot Contract

The shot record must inherit rather than recreate the Scene Contract:

- `storyBeatId`, `shotPurpose`, `owner`, `taskVerb`, and `visibleChange`;
- `startState`, `actionTrajectory`, `reaction`, and `resultState`;
- exact subjects, blocking, facing, gaze, hands, props, costume state, and movement vector;
- emotional intention and observable performance behavior;
- camera position, lens/size, height, side of axis, motion, lighting, and audio;
- `cutIn`, `cutOut`, handles, and whether the cut is internal or a generation seam.

For motion-capable interfaces, `actionTrajectory` should compile to trajectories or keyframes. Otherwise it should compile to concise spatial instructions, not ornamental prose. Research on motion prompting supports trajectories as a stronger control than text alone when the model exposes them. [Motion Prompting](https://arxiv.org/abs/2412.02700)

### 5. Generation Run Contract

A run is a delivery container, not a dramatic unit. Its contract should contain:

- ordered shots and scene segments;
- target duration, handles, intended internal cuts, and dialogue/audio timing;
- model/version/mode and live capability snapshot;
- complexity vector: event count, subjects, interactions, scene switches, camera changes, dialogue density, and reference load;
- incoming canonical state and outgoing planned state;
- selected reference pack and why each reference is relevant;
- model-mode conflicts and fallback plan;
- dependency on an accepted prior run;
- packing rationale and predicted risks.

For a run spanning scenes, compile an explicit reset block at every scene boundary:

```text
SCENE CHANGE — 00:12.0
Cause from prior scene: Elena chooses the screen over the kiss.
Now: ten years later, different auditorium, sparse audience.
Reset: cast, wardrobe, location, time, light, atmosphere, audio bed.
Carry: Elena identity, love of cinema, gaze motif, screen-light palette.
First event: laughter escapes before she notices she is alone.
```

Global continuity facts, run-level context, and local shot instructions must remain separate blocks. Do not concatenate the entire bible into every prompt.

### 6. Boundary Contract

Every boundary between independent generations becomes a first-class object.

```json
{
  "boundaryId": "run01_run02",
  "type": "continuous_handoff",
  "narrativeLink": {
    "outgoing": "Elena settles as the projector starts",
    "incoming": "The screen image registers on her face"
  },
  "mustMatch": ["youngElena.identity", "wardrobe", "seat", "screenDirection", "screenLight"],
  "mustChange": ["shotSize: medium -> close"],
  "carriers": {
    "action": "her head finishes turning toward the screen",
    "attention": "eyes remain on the same screen position",
    "audio": "projector and film score continue across the cut"
  },
  "plannedOutState": "state.sc01.shot1C.end",
  "observedOutState": null,
  "requiredInState": "state.sc01.shot1D.start",
  "evidence": { "tailFrames": [], "headFrames": [], "audioWindow": null },
  "verdict": "unreviewed"
}
```

Use four boundary types:

| Type | Meaning | Default strategy |
|---|---|---|
| `internal_cut` | Both shots are in one model call | Time and describe the cut; model shares full context |
| `continuous_handoff` | Same event/place/time continues across calls | Highest-risk seam; require actual tail evidence, long-term refs, action/motion/audio carrier, and sequential generation |
| `motivated_event_boundary` | Place/time/action changes, but the next scene is a consequence | Preserve narrative and affective state; use question, decision, sound, gaze, graphic, or motif as carrier |
| `intentional_rupture` | Disorientation is an authored choice | Declare the intended break and verify that identity/story comprehension still survives |

A clean break is therefore one possible visual treatment inside a boundary contract—not the definition of continuity.

### 7. Run-packing policy

Replace “fill the duration ceiling” with:

> Choose the fewest generation runs whose contents fit the live model's hard limits **and** its validated coherence envelope. Never split for a purely editorial reason such as “this beat deserves its own generation.” Never combine merely because the seconds fit.

The envelope is model/version/mode-specific and should be learned from the plugin's own results. Its inputs are:

- total seconds and handles;
- number and ordering of observable events;
- number of recurring and newly introduced subjects;
- interaction/prop-transfer count;
- internal edit count and scene-switch count;
- camera-motion and blocking complexity;
- spoken dialogue and lip-sync load;
- number/type/size of references;
- output resolution and audio mode.

The API ceiling remains a hard cap. It is not the target. A packer should maximize expected accepted footage, not raw generated seconds:

```text
maximize shared-context benefit
       - predicted event-omission risk
       - predicted identity/state drift
       - seam risk
       - reference-attention overload
       - expected regeneration cost
```

Initially this can be a transparent profile table. After enough labeled runs, calibrate it from telemetry. Always record model version, mode, duration, shot/event count, reference count, result, and rejection reason.

For the Elena example, shots 1A–1D should be considered together because they form one causal action and fit the nominal duration. They should be split only if the current model profile predicts that this event/cut/reference load is outside its safe envelope—not because 1D is emotionally important. If split, the 1C→1D boundary requires an actual-state handoff.

### 8. Two-memory conditioning

Build each dependent run's reference pack from:

1. **Canonical production memory** — approved character, wardrobe/state crop, location, hero prop, and visual-language references relevant to the next run.
2. **Recent seam memory** — several actual outgoing frames, not only one final frame; observed pose, motion, gaze, prop placement, light, and a short audio window.

Retrieve only references visible or causally relevant to the run. Conditioning on everything increases cost and can dilute attention.

The compiler must branch by current model capabilities:

- first/last-frame mode when supported and compatible;
- reference-image/video/audio mode when supported;
- extend-video mode for true continuation when appropriate;
- text-plus-canonical references as a fallback.

Do not assume first/last frames and arbitrary references can always be combined. Vendor schemas and limits change, so capability resolution must happen from the live model catalog immediately before approval and dispatch.

Previous-tail video and audio references are promising experiments, not automatic defaults. Test for improved continuity, contamination of the new scene, prompt adherence, latency, and cost.

### 9. Verification and state commitment

Use three distinct gates.

#### Before generation

- deterministic state lint: fact, timeline, knowledge, prop, wardrobe, injury, presence, geography, and unresolved-thread checks;
- dramatic lint appropriate to scene mode: purpose, task, resistance or function, visible change, turn/handoff, and causal link;
- run feasibility: live hard limits, coherence profile, reference capacity, and prompt-mode compatibility;
- independent critic produces typed findings and evidence paths, not a wholesale rewrite;
- repair only the failing field, then ask for approval at meaningful gates.

#### As soon as two adjacent runs exist

- assemble them immediately with intended handles and audio;
- extract tail/head frame strips plus motion and audio windows;
- inspect physical continuity, affect/performance, cinematic grammar, narrative cause/consequence, and sound;
- watch the join at speed in context, not only as stills;
- approve, trim, use an alternate candidate, or regenerate the smallest failing run/seam.

#### On acceptance

- compare planned output state with observed output state;
- reject the clip or explicitly approve the deviation;
- commit only `observed_approved` state to the ledger;
- invalidate dependent ungenerated prompts when the approved state changes;
- reopen downstream joins if a run is rerolled at finishing resolution.

Machine evaluation should flag likely errors; it should not certify the cut. ShotBench shows that even strong vision-language models remain weak on fine visual and spatial questions, while VBench/VMBench show why identity/background stability and motion quality should be scored separately. [ShotBench](https://arxiv.org/abs/2506.21356), [VBench](https://openaccess.thecvf.com/content/CVPR2024/html/Huang_VBench_Comprehensive_Benchmark_Suite_for_Video_Generative_Models_CVPR_2024_paper.html), [VMBench](https://openaccess.thecvf.com/content/ICCV2025/html/Ling_VMBench_A_Benchmark_for_Perception-Aligned_Video_Motion_Generation_ICCV_2025_paper.html)

## Decisions and scope (2026-09-05)

The first implementation of this plan (branch `reverted/continuity-first-workflow`,
reverted the same day) rewrote 24 files and could not be verified. It also
recorded four decisions the owner took that day; they are kept here because
they bound every later slice:

- **A. Pilot** — one run, as today; no two-run pilot.
- **B. Run packing** — the fill-the-ceiling doctrine of 2026-09-03 stands; no
  coherence profile; measurements recorded only.
- **C. Verification** — any check runs inside the drafting turn and never adds
  a user turn.
- **D. Boundaries** — run edges stay clean breaks
  (`skills/film-scenes/references/SEAMS.md`); no
  `continuous_handoff`, no tail frames, audio windows or observed state carried
  into another generation.

**Implemented — the writing half (§1–§4 and the story side of §5):** a story
spine and a scene contract per scene, written before prose and shown as the
beat sheet (`skills/film-development/references/DRAMATURGY.md`); the
opening-readability rule and the playable-action shape; shot cards that name
the beat they serve and inherit task and change from it
(`skills/film-development/references/BREAKDOWN.md`); `story`,
`scenes[].contract` and `shots[].beat` / `goal` / `task` / `change` in
`film.json` (`skills/film/SKILL.md`); Blocks 1, 8 and 12 compiled from those
fields, and a SCENE CHANGE preamble at a scene boundary inside a run
(`skills/film-scenes/references/PROMPT-BLOCKS.md`); the board feedback rule made
explicit about which shot fields it replaces
(`skills/film/references/WIDGET-FEEDBACK.md`). Instruction-only; no widget, server or tool-description
change. Phase 0's fixture set was not built first; the slice is instruction-only
and the measurement remains owed.

**Not adopted, by decisions A–D:** §5's complexity vector and packing
rationale, §6 Boundary Contracts and their evidence payload, §7 run packing by
coherence envelope, §8 two-memory conditioning, §9's adjacent-run assembly
gates and observed-state commitment, and the Phase 0–5 programme below. They
remain in this document as the research record. The one baseline recorded so
far — the Elena session's six-run partition — is on the reverted branch.

## Implementation plan

### Phase 0 — Establish the baseline

Goal: know which changes actually improve films.

Deliverables:

- 8–12 fixed microfilm fixtures covering continuous action, dialogue/eyelines, prop handoff, emotional carry, location/time jump, recurrence after absence, montage, multi-scene runs, and intentional rupture;
- a blinded review rubric and error taxonomy;
- telemetry for model/version/mode, duration, events, subjects, cuts, references, credits, latency, candidates, acceptance, and repair reason;
- current-workflow baseline at equal model and credit budgets.

Exit criterion: repeatable scores and labeled failure clips exist before continuity rules are rewritten.

### Phase 1 — Fix scene and action authorship

Goal: stop losing narrative and physical intent before prompt assembly.

Deliverables:

- Scene Contract and canonical-state schemas in `film.json`;
- an opening-readability gate;
- scene-mode-aware narrative/state lint;
- shotlist fields for purpose, owner, task verb, action beats, start/result state, and causal links;
- breakdown and shotlist approval show the same information that reaches generation.

Exit criterion: no prompt compiler field invents the primary action, start state, or dramatic function after shot approval.

### Phase 2 — Make boundaries and runs first-class

Goal: design continuity at the actual failure boundary.

Deliverables:

- Shot, Run, and Boundary Contract schemas;
- explicit multi-scene prompt reset grammar;
- reconciled opening rules for film, new scene, intra-scene run, and intentional rupture;
- run-packing feasibility pass covering duration, events, cuts, scene switches, dialogue, and references;
- required adjacent-run pilot for every multi-run film.

Exit criterion: every generation edge is typed, justified, evidence-bearing, and reviewable before credits are spent on the rest of the film.

### Phase 3 — Add model-aware memory and scheduling

Goal: condition each generation with the right history.

Deliverables:

- live capability snapshot and mode-compatibility resolver;
- relevant-reference retrieval from canonical and seam memory;
- sequential scheduling for dependent runs, while genuinely independent runs may remain parallel;
- experiments for multi-frame tails, source-video continuation, reference video, and audio bridge;
- versioned safe-envelope profiles per model/mode.

Exit criterion: the packer can explain why a run was combined or split, and dependent prompts use the accepted outgoing state rather than the planned one.

### Phase 4 — Make review sequence-first

Goal: approve a movie, not a folder of clips.

Deliverables:

- automatic rough assembly whenever adjacent footage exists;
- structured seam review with tail/head frames, at-speed playback, and audio;
- typed physical, affective, cinematic, narrative, and audio findings;
- alternate/trim/reframe/seam-regenerate/full-run-regenerate repair ladder;
- observed-state reconciliation and downstream invalidation.

Exit criterion: no run receives final approval in isolation when it has a generated neighbor.

### Phase 5 — Calibrate and simplify

Goal: turn validated behavior into a fast product workflow.

Deliverables:

- ablation results for each intervention;
- safe defaults by film type and model;
- removal of rules that do not improve blind review or unit economics;
- UI only for decisions users genuinely need to see or override.

Exit criterion: improvements hold across fixtures and real projects without unacceptable cost or latency.

## Repository change map

No changes below should be implemented until Phase 0's fixtures and scoring format exist.

| Area | Planned change |
|---|---|
| `skills/film-development/SKILL.md` | Insert Scene Contract, opening-readability, and state approval before screenplay prose |
| `skills/film-development/references/SCREENWRITING.md` | Add scene modes, causal handoffs, state deltas, and filmable action/reaction rules |
| `skills/film-development/references/BREAKDOWN.md` | Make blocking and state inheritance precede shot coverage; preserve its rich directing fields |
| `docs/widget-specs/shotlist-board.md` | Stop collapsing approved intent to one action sentence; expose contract fields and continuity risks |
| `skills/film/SKILL.md` | Extend `film.json` with canon, state timeline, Scene/Shot/Run/Boundary Contracts, findings, evidence, and approvals |
| `skills/film/references/PIPELINE.md` | Add gates, dependency-aware scheduling, state invalidation, and observed-state commitment |
| `skills/film-scenes/SKILL.md` | Replace duration-only packing with hard-cap plus safe-envelope packing; require adjacent-run pilot |
| `skills/film-scenes/references/PROMPT-BLOCKS.md` | Compile global/run/shot context separately; add explicit scene resets and observed boundary input |
| `skills/film-scenes/references/SEAMS.md` | Replace “clean break means nothing aligned” with typed boundary contracts and carrier priorities |
| `skills/film-assets/*` and `asset-review.md` | Make state panels independently addressable; test recurrence across separate calls, not just one run. **Half done 2026-09-07**: state panels are now independently addressable as *views* — each panel the film uses is cut out of the approved sheet into its own image at lock, and a run's `imageUrls` carries views only (no widget change was needed). Cross-call recurrence testing is still open. |
| `skills/film-edit/*` | Assemble early, review every generated neighbor, persist seam verdicts, and repair minimally |
| `skills/film-finishing/*` | Clarify that any necessary reroll is run-level and reopens picture-lock/continuity gates |
| `evals/continuity/*` (new) | Store fixtures, rubrics, profiles, anonymized results, and regression thresholds |
| `references/SCENE-CONTRACTS.md` (new) | Canonical schema, examples, lints, exceptions, and repair rules |
| `references/CONTINUITY-LEDGER.md` (new) | State categories, provenance, observed-state reconciliation, and conflict policy |

The first implementation should remain mostly schema, instructions, and evaluation. A large new widget or multi-agent framework is not needed to prove the concept.

## Evaluation design

### Test matrix

Each fixture should be generated under the same model/version, resolution, candidate count, and credit ceiling for:

1. current workflow;
2. Scene Contract only;
3. Scene Contract plus state ledger;
4. Shot/Run/Boundary Contracts;
5. canonical references plus actual seam memory;
6. model-calibrated run packing;
7. the full proposed pipeline.

Additional ablations should isolate last frame, multiple tail frames, short prior-video reference, audio bridge, scene-reset block, reference retrieval, and sequential scheduling.

### Metrics

| Dimension | Measures |
|---|---|
| Story | required-event completion; brief fidelity; causal link comprehension; scene purpose/turn recognition |
| State | contradiction count by severity; prop/wardrobe/injury/knowledge/location persistence |
| Boundary | severe seam defects per cross-run join; action, gaze, direction, pose, light, affect, and audio continuity |
| Image/motion | identity/background stability; object integrity; motion coherence; flicker; camera compliance |
| Editing | usable handles; trim survivability; alternate-shot success; assembled-sequence rating |
| Economics | first-pass accepted seconds; candidates and credits per accepted minute; latency; seam-only versus full-run repairs |

Reviewers should see randomized assembled sequences without knowing the condition. Automated scores triage and stratify; humans make the final continuity and story-flow judgment.

### Provisional launch gates

Ratify exact thresholds after the baseline, but a useful initial bar is:

- at least 30% fewer high-severity cross-generation seam defects;
- at least 20% better first-pass accepted-seconds ratio;
- no more than a 5% decline in brief/event completion or aesthetic rating;
- every accepted generation boundary has a typed verdict and frame/audio evidence;
- no silent state mutation reaches a dependent run.

If longer packing improves identity but lowers event completion, the profile must shorten or simplify the run. If seam conditioning improves the join but contaminates a new scene, restrict it to continuous handoffs. Product behavior should follow the measured tradeoff.

## First implementation slice

The highest-value, lowest-regret slice is:

1. build the continuity fixture set and baseline;
2. add `storyState`, `sceneContracts`, and typed `stateDelta` to `film.json`;
3. preserve structured action beats through the shotlist into prompt compilation;
4. add `boundaryContracts` with planned and observed state;
5. pilot two adjacent independent runs and review them as an assembled pair;
6. compare against the current workflow before adding UI or advanced conditioning.

This slice directly tests the central hypothesis: better movies come from preserving cause, action, state, and performance across the whole pipeline—not from decorating disconnected clips with more transition instructions.

## Sources and confidence

The recommendation combines repository inspection, the supplied research document, peer-reviewed research, professional production guidance, and current official model documentation. The strongest evidence supports explicit planning/state, action/audio continuity, complexity-aware generation, dual memory, and sequence-level review. The exact schemas, thresholds, scoring weights, and model envelopes are product hypotheses and must be calibrated on plugin footage.

Selected primary sources:

- [Re3: Generating Longer Stories With Recursive Reprompting and Revision](https://arxiv.org/abs/2210.06774)
- [DOC: Improving Long Story Coherence With Detailed Outline Control](https://aclanthology.org/2023.acl-long.190/)
- [STAGE: screenplay understanding through a shared world representation](https://arxiv.org/abs/2601.08510)
- [MovieGraphs: Towards Understanding Human-Centric Situations from Videos](https://arxiv.org/abs/1712.06761)
- [FactTrack: Time-Aware World State Tracking in Story Outlines](https://aclanthology.org/2025.naacl-long.144/)
- [The Impact of Continuity Editing in Narrative Film on Event Segmentation](https://pmc.ncbi.nlm.nih.gov/articles/PMC3208769/)
- [Edit Blindness](https://bop.unibe.ch/JEMR/article/view/2264)
- [TC-Bench](https://aclanthology.org/2025.findings-acl.241/)
- [StoryEval](https://openaccess.thecvf.com/content/CVPR2025/html/Wang_Is_Your_World_Simulator_a_Good_Story_Presenter_A_Consecutive_CVPR_2025_paper.html)
- [Long Context Tuning for Video Generation](https://openaccess.thecvf.com/content/ICCV2025/html/Guo_Long_Context_Tuning_for_Video_Generation_ICCV_2025_paper.html)
- [StreamingT2V](https://openaccess.thecvf.com/content/CVPR2025/papers/Henschel_StreamingT2V_Consistent_Dynamic_and_Extendable_Long_Video_Generation_from_Text_CVPR_2025_paper.pdf)
- [OpenAI: Video generation models as world simulators](https://openai.com/index/video-generation-models-as-world-simulators/)
- [VBench](https://openaccess.thecvf.com/content/CVPR2024/html/Huang_VBench_Comprehensive_Benchmark_Suite_for_Video_Generative_Models_CVPR_2024_paper.html)
- [VMBench](https://openaccess.thecvf.com/content/ICCV2025/html/Ling_VMBench_A_Benchmark_for_Perception-Aligned_Video_Motion_Generation_ICCV_2025_paper.html)