comic-continuity-audit — the Motif-State-Table Audit (Phase 1, step S11)

The diegetic-continuity AUDIT step of the [`comic-author`](../comic-author/SKILL.md) suite: verify that a baked panel obeys the WORLD-LOGIC the comic committed to — time / prop-state / motif-arc / metric-value / causality across cuts — distinct from identity/style (comic-director's panel_gate already covers "does the character LOOK the same"; this covers "does the WORLD stay consistent"). The audit is not vibes: it reads the pre-committed MOTIF STATE TABLE authored by comic-storyboard-creator (the motif_ledger node) and checks each baked panel STRICTLY against its own row + the film's global invariants. This skill is the AUDIT producer, not the gate: it emits a continuity review node (world-state evidence) that comic-cross-layer-gate --gate continuity collects and adjudicates — the loop can DRIVE but it cannot ACQUIT (acceptance-gate). On a same-panel miss it requests a retry_panel; a cross-frame motif break is handed to the page assembly_gate's drift set (seed-anchored comic panels are independent — there is no cross-panel rollback in this image pipeline, spiral_engine.js:54). It ports the real procedure of aris_movie's continuity-audit (Gemini-as-fact-extractor → Claude-as-deterministic-judge → violations → routed repair) onto stills, but anchors it to our pre-committed per-dimension-per-panel ledger instead of asking a holistic judge to infer intent.

Cardinal lesson baked in as a predicate, not prose: the audit IS the table. The audit never invents a rule — it reads the motif_ledger and flags any panel whose observed value contradicts that panel's row. And it is cast-aware: a panel that simply does not contain a character (the duo are absent in S01/S03/S06/S18/S20/S22 by design) is design, NEVER a drift penalty (absence≠drift). This is the concrete fix for the B03 cross-frame FALSE-drift: IDENTICAL `min=0` scores across re-bakes were the fingerprint of a broken, cast-blind RUBRIC — not a broken artifact. When scores don't move across repairs, audit the JUDGE (is it reading the table? is it penalizing intended absence?), do not keep regenerating the panel.

  motif_ledger (the TABLE) ─▶ ① LOAD  attempt + prior-accepted + this panel's table row + active continuity_constraints
                                  ▼
                            ② EXTRACT  Gemini auto-gemini-3, ONE analyzeFile per panel image, FACT-ONLY (no scoring, no comparison)
                                  ▼
                            ③ JUDGE  Claude deterministic: observed ⊖ table-row  AND  global invariants
                                  │       (DDL monotonic · bounce S02=ONLY MAX · metric columns never co-mingle · MIRROR LOCKS)
                                  ▼
                            ④ CAST-AWARE FILTER  intended-absence ≠ drift; design variation ≠ drift  (read the row's design intent)
                                  ▼
                            ⑤ EMIT  one continuity review node (always) + 0-N continuity_constraint candidates + observed_state patch
                                  ▼
                       contradiction? ─ yes ─▶ same-panel miss: request retry_panel (failure_mode.repair_pattern = positive invariant)
                                  │            cross-frame break: add panel id to the page assembly_gate drift set (NO cross-panel rollback)
                                  │ no
                                  ▼
                            ⑥ the continuity review node is COLLECTED by comic-cross-layer-gate --gate continuity (the gate ACQUITS, not this skill)

Constants

• THE GATE = THE TABLE. The audit reads the motif_ledger node (its columns / rows / invariants /

mirror_locks) and checks each panel against its own row. It does not invent rules; an un-tabled claim is out of scope (escalate to the storyboard layer, do not adjudicate it).

• MOTIF_TABLE_COLUMNS (verbatim, the dimensions the audit reads) =

Panel | Mug（ML RESEARCH motif 杯）| DDL | Tok|yo | exact_parse | claim_delta | bounce.

• FACT-EXTRACTOR = Gemini auto-gemini-3 via mcp__gemini__analyzeFile — ONE call PER panel image

(analyzeFile takes ONE filePath, never a batched array). Prompt is FACT-ONLY: "Do NOT score quality. Do NOT compare to anything. Just extract what you SEE in THIS ONE panel." For a multi-panel page, sample the salient panels (first + last + the dominant big-frame panel), one analyzeFile each.

• JUDGE = Claude (this agent), deterministic predicate evaluator over the observed JSON vs the table row

+ the global invariants. The judge is logic, not per-pixel taste.

• CROSS-MODEL INDEPENDENCE — the executor that baked the panel (the Codex-family mcp__codex__codex

sidecar bake) is NOT a judge here; it never self-acquits (reviewer-independence). Gemini extracts, Claude judges; the generator family is excluded from this audit.

• GEMINI_FALLBACK — a frame Gemini fails: retry once; if it still fails, **mark that dimension

indeterminate, never default to satisfied/violated**. A false negative wastes a re-bake; surface ambiguity.

• MAX_CONSTRAINTS_TO_CHECK = 20 (cap; archived/superseded continuity_constraint nodes skipped) ·

GEMINI_MODEL = auto-gemini-3 (never downgrade, reviewer-routing).

• OUTPUT = a review node (always) + story/CONTINUITY_TRACE.md + observed_state.json per panel +

0-N continuity_constraint candidate nodes + (on mismatch) a decision + a failure_mode + edges.

Input contract — what it reads, what it writes (the wiki node it touches)

This skill is pure audit — it produces the world-state evidence (a continuity review node) that comic-cross-layer-gate --gate continuity later COLLECTS (via the reviews edge) and fuses against the motif_ledger. The continuity verdict belongs to that gate (it scores the gate's four dims ledger_row_complete / invariants_hold / mirror_locks_paired / design_aware); this skill only writes the review + (on a contradiction) requests the engine's bake-time repair (retry_panel, or a cross-frame add to the page assembly_gate's drift set). It does NOT feed a bake-time panel_gate KEEP — verified: spiral_engine.js panelVerdict computes narr from cc.narrative_beat_fidelity / cc.composition_story and never reads a `plot_continuity` field, so this skill never claims MIN-fusion influence over the bake-time KEEP.

Reads (per schemas/node_schema.json, node/comic/3.0):

• the `motif_ledger` node (node_type: "motif_ledger", id motif:<slug>) — payload columns, `rows`

(the per-panel ground truth), `invariants` (DDL monotonic; bounce-uniqueness; metric-column separation), `mirror_locks` (the non-adjacent paired constraints). This is THE spec the audit checks against (and the gate then adjudicates).

• the `panel_attempt` node under audit (node_type: "panel_attempt", id attempt:<slug>) — payload

source_panel_id, `image_path` (the single baked panel PNG, or a page of panels), attempt_index.

• the MOST RECENT accepted panel_attempt on the same lineage = PRIOR_ACCEPTED (the implicit reference

for monotonicity); if none → bootstrap-only pass (vacuous-satisfied, still emit a review node).

• all live `continuity_constraint` nodes — filter on the payload boolean `payload.active == true` (the

designed institutional-memory "is this constraint live" flag, NOT the node status; skip nodes whose status is superseded/rejected). Per validate_wiki.py PAYLOAD_REQUIRED["continuity_constraint"] the payload carries exactly family, constraint_text, applies_to_panel_ids, source_node_id, active — read all five.

Writes (every node-id matches the schema pattern ^(…|review|decision|fail):[a-z0-9_-]+$; every payload carries exactly the validate_wiki.py PAYLOAD_REQUIRED fields for its type):

• always one `review` node (node_type: "review"). **Node-id and reviewer are NAMESPACED to avoid a

byte-collision with the bake-time `panel_gate` CC review: id review:continuity_<panel>_<attempt>_cc (NOT `review:<panel>_<reviewer>` — that is byte-identical to the existing `review:panel_s01_a01_cc` and would OVERWRITE it), reviewer continuity_cc* (a logic judgment, not the bake-time per-pixel `cc`), `gate_kind: "continuity"`. The four continuity-gate dims go under `payload.review_scores` — that map is the ONLY copy [`comic-cross-layer-gate`](../comic-cross-layer-gate/SKILL.md) `--gate continuity` reads (its §① loads each review's `payload.review_scores`): `review_scores = {ledger_row_complete, invariants_hold, mirror_locks_paired, design_aware}` (each 0–5, the EXACT dims it fuses) + a `timed_out` bool + `notes` at payload top-level. The 3 schema-required keys are `target_node_id` (the `motif_ledger` = `motif:<slug>`, the node `--gate continuity` is passed + adjudicates), `reviewer`, `gate_kind`; `status: "complete"`. Append a `reviews` edge `review:continuity_<panel>_<attempt>_ → motif:<slug> (the motif_ledger is the exact node the continuity gate collects reviews INTO; the audited attempt is named in the review node_id + carried in notes — never target attempt:` (the continuity gate does not adjudicate the attempt), never `reviewed_by`, the opposite direction). (The bake-time panel_gate reviews use flat top-level dim keys for the engine's reader; this AUTHOR-layer continuity review uses review_scores because that is the map the author gate reads.)*

• on a contradiction a `decision` node (node_type: "decision", id decision:continuity_<panel>_<slug>,

payload schema-required target_node_id, verdict, gate_kind — gate_kind: "continuity", status: "final") whose `verdict` is `retry_panel` (same-panel mug/tokyo/metric miss) or `assembly_drift` (a cross-frame motif break — routed to the page assembly_gate's drift_panels, NOT a per-panel rollback); plus a `failure_mode` node. (Vocabulary note, by design: `retry_panel`/`assembly_drift` are bake-time REPAIR REQUESTS consumed by the engine/`comic-director` — a deliberately SEPARATE vocabulary from the cross-layer `--gate continuity` acquittal verdicts `{approve, revise}`; two different decision nodes with two different jobs, and the node schema does not constrain verdict strings, so both validate.) That `failure_mode` node (node_type: "failure_mode", id fail:continuity_<panel>_<slug>, payload schema-required `layer: "continuity"`, `affected_shot_ids`, `active: true`, status active) carries a `repair_pattern` that is the POSITIVE INVARIANT for the next bake — e.g. "S06 DDL reads exactly `T-18:40` so `18:40 > S07's 18:30` holds the countdown", never the ban. (Dataflow, exact: the engine sources the next bake's invariant from the panel-gate reviewer's in-memory failure_mode_positive_invariant → verdict.invariant → pending[pid] → the next generate_panel; the persisted failure_mode.payload.repair_pattern is the audit SINK written FROM that same invariant, NOT read back by the engine — so author repair_pattern as the identical positive invariant the reviewer emits.) Append a `decides` edge (decision → attempt, verdict on the edge) + a `failure_of` edge (failure_mode → attempt). No `rollback_of` edge — that edge is for the page-level assembly rollback the engine actually performs, not a (non-existent) per-panel chained rewind. Edge vocab used here, all in validate_wiki.py EDGE_TYPES: reviews / decides / failure_of (+ the existing attempt_of minted upstream).

• 0-N `continuity_constraint` candidate nodes (institutional memory; id cont:<slug>, payload

family, constraint_text, applies_to_panel_ids, source_node_id, active) — an implicit check that fires twice on the same lineage gets promoted to an explicit constraint node so the next run checks it cheaply.

• patches the attempt payload with observed_state (allowed by additionalProperties: true) — this is the

progressive chain: the NEXT audit has a verified reference instead of re-inferring it.

Two fail-closed engine contracts (refuse, do not paper over)

The audit runs only on artifacts the pipeline guarantees; if a precondition is missing it fails closed and points at the offending node rather than silently auditing a malformed unit:

1. Every panel needs a `content_svg`. The baked panel must trace to a blueprint node whose payload carries

a non-empty content_svg (the deterministic SVG blueprint that was the generation condition). No content_svg → the panel was free-baked, the table-row comparison has no anchor → REFUSE, route back to comic-blueprint-author. (You audit what was committed, not a vibe.)

1. A baked panel carrying a `content_svg` needs `expected_literals`. For any panel whose effective

text_mode is baked AND that carries a content_svg (cfg_usable's exact trigger), the blueprint's expected_literals (the ascii-tokenizable numbers/labels: e.g. ["REJECT","37","T-16:05"]) MUST be present; they are the literal values the metric/DDL columns are checked against. Missing/empty expected_literals on a baked figure panel → REFUSE (the fail-closed gate cannot verify exact_parse/claim_delta/DDL without them). text_mode: "html" (pure-scene) panels carry no literals — they are gated on stray_text_absence, and their continuity is judged on the scene-state columns (mug / bounce / cast presence) only.

THE AUDIT PREDICATES — what this skill checks and reports to the continuity gate

This is the pre-gate routing (the audit's own predicates) — NOT the gate's APPROVE condition. The gate's APPROVE predicate is owned by comic-cross-layer-gate --gate continuity (ledger_row_complete ≥ 4 AND invariants_hold ≥ 4 AND mirror_locks_paired ≥ 4 AND design_aware ≥ 4, with a structural HARD VETO on any invariant violation). This skill computes the per-column / per-invariant findings below, folds them into those four dims, and writes them to the review node the gate fuses.

Audit columns (the six table columns; each is a machine-checkable predicate the audit verifies from the table alone — they roll up into the gate's invariants_hold + ledger_row_complete dims):

• `mug` — tracks ONLY the ML RESEARCH motif mug. States: hot (two stable steam wisps = the film's

temperature origin) / fading (one thin wisp) / cold (no steam + milk skin). DESIGN-AWARE DISAMBIGUATION: the </> mug is an environment prop, tagged env, and ignored — a panel showing a </> mug is NOT a motif-mug appearance and must NOT be flagged. The B01↔S20 bookend cold is "the hardest continuity constraint" (S20 must read stone-cold + milk-skin, same mug as S01's hot origin).

• `ddl` — global invariant "DDL 全片单调递减，永不回拨" (monotonic non-increasing across the ENTIRE

film, never rewinds). Exact 16-value spine: T-24:00:00 → 19:42 → 19:42 → 18:55 → 18:40 → 18:30 → 17:46 → 17:02 → 16:21 → 16:05 → 05:12 → 02:58 → 02:41 → 01:57 → 00:42 → 00:27(submitted). Two consecutive 19:42 (S03/S04, same-instant rhyme) are allowed because non-increasing; S06=18:40 exists SOLELY so 18:40 > S07's 18:30 holds the never-rewind rule.

• `tokyo` — the broken-JSON chip {"city":"Tok|yo"} lifecycle:

absent → first-micro (S09, sub-threshold, NOT gated) → hero/gated center (S10) → evidence thumbnail (S11) → tiny as-prior (S12a) → REPAIRED {"city":"Tokyo"} ✓ parsed (S17) → single unlabeled dark star (S22).

• `exact_parse` vs `claim_delta` — the two metric columns that "永不混写" / never co-mingle:

exact_parse ∈ {0.60, 0.71, 0.66, 0.78, 0.89}, claim_delta ∈ {+6.2, +1.4}. A value written into the wrong column is a violation (a +6.2 appearing where an exact_parse should be, or vice-versa).

• `bounce` — uniqueness invariant "S02 是全片唯一 MAX" (S02 is the film's ONLY maximum bounce). Every

later high is annotated "低于 S02"; post-fall peaks are BANNED (S12a = "attempted celebration, ARRESTED before becoming a jump"); the arc closes at S21 "smallest bounce (弧线终读数)".

Cross-panel MIRROR LOCKS (non-adjacent paired constraints, beyond the per-row table — read from motif_ledger.mirror_locks):

• S11 REJECT ↔ S16 ACCEPT — same diagonal stamp geometry/angle (both from stamp_family_v1.svg's shared

verdict-card geometry) + identical stamping-arm pose. The audit checks the geometry matches, not the word.

• S02 unique-MAX ↔ S21 smallest — the bounce-thermometer endpoints (a second MAX at S21 is a veto).
• S16b labeled star-map ↔ S22 wordless constellation — same node coordinates from

wiki_starmap_nodes_v1.json (禁目测 / no eyeballing — the JSON is the only truth source for both; S22 is programmatically derived, never re-laid-out by eye).

• S20/S21 set-continuity — same room/desk/camera as S01 (S01's baked image is the additional condition ref).

HARD VETO FINDINGS (any one → the audit reports the gate's invariants_hold dim as violated (≤1) → the gate structurally HARD-VETOes ADVANCE; this skill requests retry_panel for a same-panel miss, or routes a cross-frame break to the assembly_gate drift set):

• DDL rewind — DDL is a *COUNTDOWN of remaining time, declared monotonic NON-INCREASING* (永不回拨).

Walk the accepted chain in `sequence_index` order; the violation is a LATER panel showing MORE remaining time than an earlier panel (the countdown went UP / reset), OR any DDL value not matching the committed 16-value spine in order. An earlier panel having more remaining time than a later one is the CORRECT case, never a violation. (Canonical bug: S06's draft T-15:27 showed LESS remaining than S07's T-18:30 (15:27 < 18:30, i.e. the deadline jumped closer then snapped back further away) — a rewind; fixed to T-18:40 so the remaining-time sequence 18:55(S05) → 18:40(S06) → 18:30(S07) is non-increasing.)

• a second bounce == MAX — any post-S02 panel reading MAX bounce (the uniqueness invariant).
• a cross-written metric column — an exact_parse value in the claim_delta column or vice-versa.
• a broken MIRROR LOCK — REJECT/ACCEPT geometry mismatch, or S16b↔S22 coordinates that don't derive from

the shared JSON, or S20/S21 set drift off S01.

SCORING — how findings roll into the FOUR continuity-gate dims this audit writes (ledger_row_complete, invariants_hold, mirror_locks_paired, design_aware, each 0–5; the gate ADVANCES iff all four ≥ 4 with a HARD VETO on any invariant violation). Per dim: clean / bootstrap → 5 · minor finding → 4 · major → 2 · critical → 1 · ≥2 critical on that dim → 0. SEVERITY map: any ddl / bounce-uniqueness / metric-cross-write violation = critical on invariants_hold; a broken mirror-lock = critical on mirror_locks_paired; a missing/blank table variable = a hit on ledger_row_complete; a mug / tokyo / motif-state miss = major on invariants_hold; an intended-absence false-flag (caught in Phase 3) = a hit on design_aware; an indeterminate (Gemini-confidence < 0.6) = minor, surfaced not vetoed. The gate (not this skill) min-fuses these dims across the collected continuity reviewers and decides advance/revise — this audit only authors the scores. (Note: this is the AUTHORING-side continuity gate's dim set; it is distinct from the bake-time `panel_gate`'s `narrative_intent`/`plot_continuity` formula in `spiral_engine.js`, which this skill does not feed.)

CAST-AWARE GUARD (do NOT penalize, per `acceptance-gate` design-awareness):

• intended absence ≠ drift — a panel whose row marks a character/motif absent or n/a (the duo in

S01/S03/S06/S18/S20/S22; bounce = n/a when the duo aren't on-panel) is correct by design; flagging it is a FALSE drift. Read the row's intent before scoring.

• intended variation ≠ drift — the warm↔dark-cyber world flip, the env </> mug, a deliberately

sub-threshold Tok|yo chip (S09, ≤1.5% frame height, below the blind-review transcription threshold) are all by-design and out of the drift contract.

• IDENTICAL scores across re-bakes ⟹ audit the JUDGE, not the panel. If the continuity dims

(invariants_hold / design_aware / …) don't move after a repair, the rubric is cast-blind or not reading the table — stop regenerating, fix the audit/gate (the B03 false-drift lesson).

Procedure (followable, one panel at a time — never batch the audit)

① Phase 0 — Load state (the table is the spec)

Parse the panel_attempt id → slug (: → __); read its image_path, source_panel_id, attempt_index. Load the `motif_ledger` node and pull this panel's row + the invariants + the mirror_locks that name this panel. Enumerate live continuity_constraint nodes (filter on `payload.active == true`, skip nodes whose status ∈ {superseded,rejected}, cap 20, prioritise those whose applies_to_panel_ids contains this panel). Resolve PRIOR_ACCEPTED = most-recent accepted attempt on the lineage. Fail-closed check now (mirror `run_comic.py` `cfg_usable` EXACTLY — never weaker than the engine floor): confirm the panel's blueprint carries a non-empty content_svg, and — if text_mode == "baked" AND a content_svg is present (cfg_usable's EXACT trigger — NO 'figure panel' sub-test, which would be narrower/weaker than the engine floor) — that expected_literals is a non-empty list where every entry is an ascii-tokenizable string (isinstance(e, str) and re.findall(r"[a-z0-9+._-]+", e.lower())); if either is missing or any literal fails that → HALT and route back (do not audit a malformed unit). Snapshot inputs to continuity_context.json. If no motif_ledger row exists for this panel → escalate to the storyboard layer (the audit has nothing to check against; never improvise a row).

② Phase 1 — Extract observed state (Gemini, fact-only, one call per image)

Call mcp__gemini__analyzeFile with `auto-gemini-3`, ONE `filePath` = the panel PNG (for a page, one call per sampled panel: first + last + the dominant big-frame). Prompt is strictly fact-only — "Do NOT score. Do NOT compare. Extract only what you SEE in THIS ONE panel." Demand a JSON with the columns this audit reads: mug_state ∈ {hot,fading,cold,env,absent,unclear} (and whether the visible mug is the ML RESEARCH mug or the </> env mug); ddl_value (the literal countdown string seen, or none); tokyo_state (absent / micro / hero / thumbnail / repaired / star, + the literal JSON string seen); exact_parse_values[] and claim_delta_values[] (the numbers seen, kept in separate arrays — do not merge); bounce_level (the executor's pose: max / high / tempered / deflate / silent / n-a, + "is the duo on-panel?"); characters_visible[]; props_visible[]; plus a free anomalies[] (the negative-space audit). Aggregation is deterministic Python, no LLM (majority/last-frame anchor for a page). On a per-frame Gemini failure: retry once → still failing → that dimension is indeterminate (conf 0.0), never defaulted.

③ Phase 2 — Deterministic judge (observed ⊖ table row + invariants)

Claude compares the extracted JSON to this panel's table row and the global invariants, as predicates:

• per-column: does mug_state match the row's mug (and is an env mug correctly ignored)? does ddl_value

equal the row's DDL? does tokyo_state match the row's lifecycle stage? are the metric values in the right columns and equal to the row?

• global invariants (across the whole accepted chain in `sequence_index` order, using PRIOR_ACCEPTED +

the spine): DDL remaining-time monotonic NON-INCREASING — flag ONLY a later panel showing more remaining time than an earlier one (a countdown rewind), or a value off the 16-spine; an earlier panel legitimately has more remaining time. Bounce S02 = ONLY MAX (no post-fall peak); exact_parse/claim_delta never cross-written.

• mirror locks for this panel: REJECT↔ACCEPT geometry; S16b↔S22 shared JSON coords; S02↔S21 endpoints;

S20/S21↔S01 set. Geometry/coords are checked structurally (禁目测 where a JSON truth source exists). Each fired check → {check, verdict ∈ {violated, satisfied, indeterminate}, evidence, severity}.

④ Phase 3 — Cast-aware filter (absence≠drift) BEFORE scoring

Re-read this panel's row intent and drop any "violation" that is actually intended: a character/motif the row marks absent/n/a; the warm/dark world flip; an env </> mug; a sub-threshold Tok|yo chip; an html panel's lack of literals. A flagged-but-intended item is a FALSE drift and is removed, not scored. If after this filter the score is identical to a prior re-bake's score, STOP and audit the rubric (cast-blindness), do not trigger another bake.

⑤ Phase 4 — Emit continuity review + constraints + observed_state patch

Write one `review` node (always; id `review:continuity_<panel>_<attempt>_cc`, `reviewer: "continuity_cc"`, `gate_kind: "continuity"` — the namespacing avoids overwriting the bake-time review:<panel>_<reviewer> panel-gate node; see the Writes contract). Write the four continuity-gate dims under `payload.review_scores` = {ledger_row_complete, invariants_hold, mirror_locks_paired, design_aware} (per the scoring table — that map is what --gate continuity reads) + timed_out + notes, and append a `reviews` edge review:continuity_<panel>_<attempt>_* → motif:<slug> (the motif_ledger — the exact node --gate continuity is passed and collects reviews INTO; NOT attempt:*, which the continuity gate does not adjudicate). Append the human-readable trace to story/CONTINUITY_TRACE.md and observed_state.json. Patch the attempt with observed_state (the verified reference for the next audit — the progressive chain). For any implicit check that has now fired twice on this lineage, emit a continuity_constraint candidate node (institutional memory) so it becomes an explicit cheap check next run. Bootstrap pass (no PRIOR_ACCEPTED): verdict is vacuously satisfied, but STILL emit the review node and seed candidate constraints from the observed state.

⑥ Phase 5 — Request repair on contradiction (executor never self-judges; NO cross-panel rollback)

On ANY hard-veto finding (DDL rewind / second MAX bounce / cross-written metric / broken mirror-lock) or a critical/major severity, write a `decision` node + a `failure_mode` node — the engine reality is the authority here (spiral_engine.js:54: "panels are independent (no chain) → only KEEP or RETRY-SAME-PANEL, NEVER rollback-to-prior"), so the verdict is NOT a per-panel rollback:

• same-panel miss (mug / tokyo / metric / a DDL value wrong on this panel) → `decision.verdict:

"retry_panel". The engine re-bakes THIS panel with the positive invariant injected — sourced from the panel-gate reviewer's in-memory failure_mode_positive_invariant (→ verdict.invariant → pending[pid] → the next generate_panel), NOT read back from the persisted node (payload.repair_pattern` is the audit SINK).

• cross-frame break (a mirror-lock between non-adjacent panels, or a DDL/bounce relation that only shows

across panels) → decision.verdict: "assembly_drift", and add the offending panel id(s) to the page assembly_gate's `drift_panels` set (the engine's assemblyVerdict returns rollback with drift_panels for page-level cross-frame repair — the ONLY rollback this image pipeline has). Do not claim a chained downstream re-bake "because each panel conditions the next" — that is false for seed-anchored comic panels.

• `failure_mode` node (layer: "continuity", affected_shot_ids, active: true) — **populate

payload.repair_pattern as a POSITIVE INVARIANT* (the audit record of the same invariant the reviewer emits for the re-bake — a sink, not what the engine reads back), e.g. `continuity_ddl_rewind` → "S06 DDL reads exactly T-18:40 so the remaining-time sequence stays non-increasing (18:55 → 18:40 → 18:30)"; `continuity_mirror_lock_broken` → "S22 star coords derive verbatim from wiki_starmap_nodes_v1.json (禁目测), matching S16b"*. State the desired target, never the ban.

Append a `decides` edge (verdict on the edge) + a `failure_of` edge — no `rollback_of` edge (that edge type is for the engine's page-level assembly rollback, not a per-panel rewind). The re-bake / assembly repair is owned by comic-director + the engine; this skill only requests it. Canonical failure-mode names to reuse: continuity_ddl_rewind · continuity_bounce_second_max · continuity_metric_cross_write · continuity_mirror_lock_broken · continuity_mug_state_wrong · continuity_tokyo_stage_wrong.

Worked example

The canonical filled ledger to audit against is examples/comic_m3_audit/story/STORYBOARD_DRAFT.md — the CORRECTED MOTIF STATE TABLE at lines 12-14 (the verbatim conventions block + the table header) and the 24 filled rows (lines 16-39) ARE the motif_ledger this audit reads. Copy this pattern exactly:

• The header + conventions (line 12-14) is the gate spec, verbatim:

| Panel | Mug（ML RESEARCH motif 杯）| DDL | Tok|yo | exact_parse | claim_delta | bounce | with the conventions "mug 列只追踪 `ML RESEARCH` motif 杯；`</>` 杯是环境道具（标 env）… DDL 全片单调递减，永不回拨 … S02 是全片唯一 MAX". The audit reads predicates off THIS, it does not author new rules.

• A real monotonic-DDL fix the audit would catch (line 21): remaining-time S05=18:55, S06=18:40, S07=18:30

is correctly non-increasing. S06 was changed from the draft's T-15:27 to T-18:40 purely so S06 still has MORE remaining than S07 (18:40 > 18:30) — T-15:27 would have shown LESS remaining than S07's 18:30 (the countdown rewound forward then snapped back). A re-baked S06 reading T-15:27 → continuity_ddl_rewind, critical on invariants_hold → retry_panel (same-panel re-bake with the positive-invariant repair).

• Split metric columns that never co-mingle (lines 23-31): exact_parse carries {0.60,0.71,0.66,0.78,0.89}

(S10 shows 0.71→0.66 while claim_delta stays —); claim_delta carries {+6.2,+1.4} (S14 shows +6.2→+1.4 while exact_parse stays —). A bake that prints +6.2 in the curve where 0.66 belongs → continuity_metric_cross_write, critical.

• bounce uniqueness (lines 17, 27, 38): S02 = MAX（全片唯一最高跳）; `S12a = attempted celebration,

ARRESTED before becoming a jump; S21 = smallest bounce（弧线终读数）. A re-baked S12a leaping to MAX → continuity_bounce_second_max`, critical.

• The CAST-AWARE rows (absence≠drift) — S01 bounce = n/a（duo 未醒）, S03 bounce = n/a（duo 不在本格）,

S20 mug = COLD … bounce = n/a（duo 未露脸）. The Gemini extractor will report "no duo on panel" and "no motif mug steam"; the judge must read these as satisfied-by-design, NOT as drift. If an S01 re-bake keeps scoring 0 because the duo are missing, the RUBRIC is cast-blind (the B03 false-drift fingerprint) — fix the judge, do not regenerate S01.

• Mirror locks — S11 REJECT ↔ S16 ACCEPT (lines 26, 32: "同一卡面几何/角度 … 精确镜像"), and S16b ↔

S22 (lines 33, 39, the wordless dark star) share wiki_starmap_nodes_v1.json (禁目测). The audit checks the geometry/coords match the shared source, not the stamp word.

The same project ships the consolidated canonical asset contract (lines 369-381) — the audit uses it to know WHICH instances are continuity-bearing (one ddl_widget_template_v1.svg for the whole 18-instance timeline; one stamp_family_v1.svg for all verdict stamps; one wiki_starmap_nodes_v1.json truth source for S16b+S22).

Hard do / don't (earned lessons)

• DO read the motif_ledger and check each panel against ITS row — the audit IS the table; never improvise

a rule the storyboard didn't commit (an un-tabled claim escalates to the storyboard layer, it is not adjudicated here).

• DO keep Gemini fact-only (no scoring, no comparison) and one `analyzeFile` per panel image — the

fact-extractor must not see the expected values (reviewer independence); the JUDGE owns the comparison.

• DO be cast-aware: read a row's absent / n/a / env intent and treat it as satisfied-by-design.

Absence≠drift. Intended variation≠drift.

• DO treat identical scores across re-bakes as a broken JUDGE, not a broken artifact — audit the rubric

for cast-blindness (the B03 false-drift lesson), do not keep regenerating.

• DO fail closed: no content_svg on the panel, or no expected_literals on a baked figure panel → REFUSE

and route back; never audit a free-baked or un-anchored unit.

• DON'T let the model that baked the panel (the Codex-family mcp__codex__codex sidecar bake) judge

its own continuity — the generator family never self-acquits; this audit is Gemini-extract + Claude-judge, and the cross-layer gate adjudicates.

• DON'T default an indeterminate (Gemini failed / confidence < 0.6) to satisfied or violated —

surface the ambiguity; a false negative wastes a re-bake.

• DON'T flag the warm↔dark-cyber world flip, the env </> mug, or a deliberately sub-threshold Tok|yo

chip — they are by-design and out of the drift contract.

• DON'T confuse this with identity/style — that is comic-director's panel_gate. This lane is WORLD-state

(time / mug-heat / metric values / bounce arc / mirror geometry / causality) ONLY.

• DON'T own ANY verdict — this skill writes a continuity review node (the four dims `ledger_row_complete /

invariants_hold / mirror_locks_paired / design_aware); [comic-cross-layer-gate](../comic-cross-layer-gate/SKILL.md) --gate continuity collects it (via the reviews edge), min-fuses, and ACQUITS. It does **NOT** feed the bake-time panel_gate (spiral_engine.js reads no plot_continuity field); on a contradiction it only *requests* a retry_panel (same-panel) or an assembly_drift` route (cross-frame), never a per-panel rollback.

Protocols (governance contracts this skill honors)

• reviewer-independence — Gemini blind-extracts facts from the

image only (never shown the expected table row); the executor that baked the panel (the Codex-family mcp__codex__codex sidecar bake) is not a judge of its own continuity.

• acceptance-gate — the loop can DRIVE but can't ACQUIT: this skill only

authors the continuity review (the four gate dims); comic-cross-layer-gate --gate continuity (a different model family) fuses + decides, and the gate is design-aware (absence≠drift) — intended absence/variation is never a drift penalty.

• reviewer-routing — Gemini auto-gemini-3 for fact extraction; never

downgrade the reviewer tier.

• artifact-integrity — the baker does not judge its own panel's

numbers; the motif_ledger is ground truth and the observed values are verified (blind Gemini extract + deterministic diff), never originated by the gate.

• review-tracing — every audit writes a review node + the

CONTINUITY_TRACE.md + observed_state.json so each verdict (and every rollback) is auditable.