Comic Cross Layer Gate

comic-cross-layer-gate — the Universal Authoring Score-Fuser + the Zero-Credit P0 Proof (Phase 1)

The acquittal organ of the [comic-author](../comic-author/SKILL.md) suite. Every authoring step (intent → style → outline → asset → storyboard → blueprint → continuity → the compiled comic.json) is a generator; none of them acquits itself. They each emit their node(s), fan out independent reviewers, and then defer to this one skill to fuse the scores into a verdict, mint the audit trail, and flip the target's status. It is the image-comic port of arismovie's 6-gate adversarial decision skill — but folded into one parameterized fuser (Codex's single-fuser design, against the per-layer split that drifts: six near-copies diverge, one fuser stays honest). The downstream per-panel panel_gate / page assembly_gate are NOT this skill — those live in [packages/core/spiral_engine.js](../../packages/core/spiralengine.js) and run at bake time; this skill is the authoring-side, pre-bake gate that decides whether a spec may advance.

> Cardinal lesson, landed as a guard not prose: identical scores across rounds = the judge is broken — > audit the rubric, do not regenerate the artifact (memory: feedback_gate_identical_scores_judge_broken). > Concretely: this gate carries a _score_fingerprint in every decision node; if round N's fused per-dim > vector equals round N−1's after the artifact changed, the gate HALTS and flags judge_suspect — > the rubric (this skill), not the spec, is the suspect. A gate that emits the same verdict regardless of the > work is worse than no gate.

  upstream step emits node(s) + fans out independent reviewers (writes review:* score-nodes + `reviews` edges)
                              │
   comic-cross-layer-gate  --gate 
                              ▼
   ⓪ PRE-CHECK   structural facts the GATE computes (asset-resolve / policy / count-band / continuity) — RAW, not opinion
                              ▼
   ① COLLECT     reviewer score-nodes via `reviews` edges — NEVER re-run a reviewer; hard-fail if none
                              ▼
   ② THRESHOLD   per-dim min-fuse (max for inverted dims); SKIP missing dims (NEVER 0-substitute); per-gate floor → threshold_verdict
                              ▼
   ③ ADJUDICATE  Codex gpt-5.5 xhigh — sees ONLY {scores + failure_mode tags + threshold_block + raw PATHS + ≤200w verbatim source + verbatim rubric}
                              ▼               (NEVER reviewer prose / notes / overall — that is the contamination vector)
   ④ ASYMMETRIC  threshold HARD-VETO over "advance"; Codex SOFT-VETO over everything else
                              ▼
   ⑤ WRITE       decision node (full audit) + (on FAIL only) a positive-invariant failure_mode the NEXT step preloads as a banlist
                              ▼
   ⑥ FLIP        target status → locked (advance) · under_review (needs-work) · rejected (terminal) ;  stdout last line: VERDICT= GATE= TARGET=

The --gate p0_proof branch is a different shape (a text-only adversarial review of the pipeline machinery, not a score-fuse over a spec) — it is documented in its own section below. It is the single most important contract this skill owns: it runs AFTER [comic-json-compiler](../comic-json-compiler/SKILL.md) and BEFORE any metered codex image_gen bake, costs zero generation credits, and must clear all blockers or the spiral is forbidden to spend a credit.

Constants

• GATE KINDS = intent | outline | asset | storyboard | blueprint | continuity | p0_proof | compile. The

legal verdict set is per-gate (below) and enforced — a verdict outside a gate's set is a hard error (the intent gate can never emit keep; the asset gate can emit locked, the intent gate cannot). The legal node status tokens a FLIP may write are ONLY {draft, pending, under_review, locked, rejected, superseded, active, complete, final} (schema enum) — a verdict (revise/regenerate/fallback) is never a status.

• REVIEWERS (collected, never re-run here): Codex gpt-5.5 model_reasoning_effort: xhigh for

every gate's ambiguity / correctness / logic pass; Gemini auto-gemini-3 wherever a second family or a visual read is needed (image inputs, UX/design). Never downgrade the tier ([reviewer-routing](../../protocols/reviewer-routing.md)).

• ADJUDICATOR = Codex gpt-5.5 xhigh, fed ONLY structured inputs (§③). Its effort is **always

xhigh** regardless of the run's --effort — effort widens fan-out, it never weakens the judge.

• FUSE RULE = min per dimension (most-pessimistic), EXCEPT inverted dims (artifact_severity,

*_severity, anything where higher = worse) use max; SKIP a dim no reviewer scored (filter the nulls) — NEVER substitute 0 (the v1.0 bug: a lite reviewer leaving a dim unscored must neither slip an advance nor force a fail).

• ASYMMETRIC TRUST = the deterministic threshold has HARD VETO over "advance" (Codex cannot overrule

approve/locked if the deterministic floor failed); Codex has SOFT VETO over everything else (a Codex revise overrules a threshold approve). Structural facts (§⓪) also hard-veto advance.

• CAPS — MAX_ASSET_REGEN = 4 then escalate the asset gate to the outline gate (abandon_shot);

re-gate (re-vote) caps fold into the calling step's attempt budget. The 准 ×3 convention (asset gate, owned by [comic-asset-review-loop](../comic-asset-review-loop/SKILL.md)): a locked verdict requires cross-model UNANIMITY in the SAME round — CC and Gemini and Codex all approve the asset that round (≥3 distinct reviewer families lock-pass together). Fewer than 3 families approving → regenerate --another-voter (re-vote to reach the third family, not re-bake); a family's hard-fail → re-bake. (NOT "three consecutive rounds" — that aris_movie video port is wrong for this repo; the owner is same-round unanimity.)

• P0 GATE THRESHOLD = blockers.length == 0 — a HARD HALT. Zero image-generation credits are spent

until clear. The review is deliberately text-only → not rate-limited → free.

• CODEX UNAVAILABLE → emit the threshold-only provisional verdict with _confidence: "low", exit code

2, and skip failure_mode compilation. Malformed adjudicator JSON → codex-reply retry ×2, then fall back to threshold-only.

• OUTPUT — a decision node in wiki/nodes/, the decides edge, a review-tracing entry per collected

reviewer + the adjudicator, and (on a FAIL verdict only) a failure_mode node. Final stdout line is EXACTLY VERDICT= GATE= TARGET= for the caller to parse.

Input contract — what the gate is given, what it refuses

The direct input is a target_node_id + a --gate . The gate reads from the wiki, it is not handed prose:

• It NEVER re-runs a reviewer. The upstream step already fanned out and wrote review:* score-nodes with

reviews edges → the target. The gate collects those nodes; if zero reviews are attached, it hard-fails (no reviews — gate is a score-fuser, not a reviewer). This is the load-bearing separation: the executor that authored the spec must not also be the one whose read of it acquits it.

• **The adjudicator sees scores + failure-mode tags + raw artifact PATHS + a ≤200-word VERBATIM source slice +

the VERBATIM rubric — and NOTHING else. It never** sees a reviewer's prose, notes, evidence, overall_assessment, or rationale ([reviewer-independence](../../protocols/reviewer-independence.md)). Reviewer prose is the contamination vector; forwarding it re-introduces the correlated blind spot cross-model review exists to break. (Structural facts in §⓪ are an exception — they are RAW artifacts the gate itself computed, not reviewer opinion, so forwarding them does not violate independence.)

• The upstream gate state machine is verdict ∈ {approve, locked, revise, regenerate, fallback} (plus the

asset-gate-only abandon_shot). Each reviewer call that feeds this gate gets file paths + an explicit === EXTERNAL CONTEXT (advisory) === fence around any cross-cutting context — never the author's interpretation. The fence is what keeps "here is the situation" from becoming "here is what to conclude".

The universal architecture (every --gate except p0_proof)

Ported verbatim from the arismovie 6-gate skill; the deterministic-JS fuse pattern is the same one the engine already proves in [packages/core/spiral_engine.js:59](../../packages/core/spiralengine.js) (panelVerdict).

⓪ Pre-check — the structural facts the gate computes

Before touching reviewers, compute the raw artifacts (filesystem facts, not opinions) the gate hard-vetoes on. These differ per gate (see each rubric) but the shape is constant: resolve every referenced asset_id, every asset is status: locked, policy fields match expected, count in band, continuity links well-formed (no dangling / out-of-order / cycle). Any non-empty violation set → revise regardless of reviewer scores OR Codex ("structural failures cannot be voted-around"). Record each as _unresolved_asset_refs / _policy_violations / _count_band / _continuity_breaks in the decision audit.

① Collect — reviewer score-nodes, never re-run

Walk reviews edges into target_node_id; load each review:* node's payload.review_scores. Build per_reviewer = {reviewer: {dim: score, ...}, failure_mode_tags: [...]}. Hard-fail if the set is empty.

② Threshold — deterministic per-dim fuse

For each rubric dimension, fuse across reviewers with min (or max for an inverted dim), skipping any reviewer that left it null. Apply the per-gate floor (each rubric below). Yield threshold_verdict ∈ {advance, revise} + a _cited_dimensions map of every fused value. This is mechanical and reproducible — a fresh reviewer can re-derive it from the table alone.

③ Adjudicate — Codex, structured inputs only

Call Codex gpt-5.5 xhigh with EXACTLY: per_reviewer scores, failure_mode_tags, the threshold_block (the fused values + the floor), the raw artifact PATHS, a ≤200-word verbatim slice of the source node (not a summary — a literal excerpt), and the verbatim rubric for this gate. Ask for a verdict in this gate's legal set + a one-line confidence + the single most important fix. Trace the call ([review-tracing](../../protocols/review-tracing.md)).

④ Asymmetric cross-check

• threshold_verdict == revise → the final verdict is a FAIL verdict no matter what Codex said (threshold

hard-vetoes advance).

• threshold_verdict == advance AND Codex returns a FAIL verdict → Codex's FAIL wins (Codex soft-vetoes

advance).

• threshold_verdict == advance AND Codex advances → ADVANCE (approve / locked, per gate).
• Record _threshold_verdict, _codex_verdict, _disagreement (bool), _confidence.

⑤ Write — decision + (on FAIL only) a positive-invariant failure_mode

Write a decision node (full audit). On any FAIL verdict, compile one failure_mode node whose repair_pattern is a POSITIVE INVARIANT ("force a status:locked ref for every mustshow asset", NOT "no draft assets") — diffusion and the next authoring step focus on what you mention, so state the desired target, not the ban (negative patterns are only for explicit banlists). Default scope is movie-local; engine-global needs explicit grounding (an over-broad failuremode poisons cross-project banlists). The next authoring step preloads this node as its banlist — the spiral's learning loop.

⑥ Flip + emit

Flip target.status (locked on advance for asset/storyboard/etc.; leave/rejected on a terminal fail). Append the decides edge. Print the parse line.

EXACT gates (dimensions · thresholds · vetoes) — ported from the aris_movie source

Every reviewer scores each dim 0–5. "ADVANCE" verdict in CAPS. Advisory dims do NOT block advance; they ride into the decision audit and the adjudicator's context.

--gate intent → verdicts {approve, revise}

• ADVANCE (APPROVE) iff completeness ≥ 4 AND safety_flag_coverage ≥ 4.
• Advisory: clarity, scope_feasibility.
• EXTRA veto: if the intent_spec.payload.confidence --page --panels --dry-run —

validates the comic.json shape, that every text_mode:"baked" figure-panel carries ascii condition.expected_literals, and prints each concrete bake prompt (no placeholders). --panels is required by run_comic.py (argparse required=True), so run this once per page in pages[] with that page's panel ids — omitting --panels exits non-zero (a false blocker).

• python3 cli/validate_wiki.py — node/edge/payload/privacy/node_id conformance against node_schema.json.

There is no reconcile_pages.py (it never existed) — these on-disk scripts are the entire deterministic core. PASS (approve) iff EVERY per-page run_comic.py AND validate_wiki.py exit 0. Record all exit codes + any stderr in the decision audit. The §⑥ FLIP target is the schema-valid decision:compile_ wiki node this gate writes (status: final) — NOT comic.json, which is a file, not a wiki node (it has no legal node_id prefix, carries no wiki_node_id, and can never be an edge endpoint).

> The folded-already clip gate (the 11-dim panel_gate: KEEP iff min(narrative_intent, plot_continuity) ≥ 4 > AND artifact_severity assemblygate are **NOT re-implemented here** — they run at bake time inside > [packages/core/spiralengine.js`](../../packages/core/spiral_engine.js). This skill is the authoring-side > gate; the engine is the artifact-side gate. They share the same fuse discipline.

--gate p0_proof — the zero-credit visual / code proof (the one contract that gates ALL spending)

Runs AFTER [comic-json-compiler](../comic-json-compiler/SKILL.md), BEFORE any metered image generation. It is a text-only cross-model adversarial review of the pipeline machinery the executor authored solo — distinct from experiment-integrity (audits results after the fact) and from the per-unit clip/panel gate (audits generated artifacts). It is a pre-production correctness proof that is deliberately free (text review, not image_gen → not rate-limited). Ported verbatim from [examples/comic_m3_audit/workflows/p0-review.js](../../examples/comicm3audit/workflows/p0-review.js).

Fan out 3 watchdog-bounded CLI reviewers, each cat'ing the REAL files into its prompt (never a Claude summary), each a DIFFERENT model family from the Claude author:

1. codex on CODE — the build script + the viewer: base64 inlining, ``

blob, missing-image handling, path resolution, the locale (T()) toggle, bubble positioning, XSS via innerHTML of T(), ?p= bounds.

1. codex on ENGINE LOGIC — spiral_engine.js: the panelVerdict formula (deadlock / wrong-keep /

skip-missing-dim / disagree gate), the retry/rollback/caps state machine (infinite-loop risk, rollback target math, kept[] filtering, localByPanel reset), generatePanel's image_gen + the gen_failed/rate-limit path, the gate prompts eliciting parseable JSON, the REPO + "/" + REPO path hack, Promise.all races.

1. gemini on DESIGN / CONTRACT / UX — is ART_BIBLE.md an executable convergence target for the

panel_gate? Does the comic.json IR scale to 24 panels + bilingual + 3 text_modes? The viewer reading experience? Drift from the design doc?

Gate schema FIND (required [reviewer, blockers, should_fix, overall]): blockers[] and should_fix[] are arrays of {file, issue, fix} — all three required per item (a blocker with no concrete fix is not a blocker, it is a complaint); plus nice[] and a one-line overall. Synthesi

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: wanshuiyin
• Source: wanshuiyin/ARIS-Movie-Director
• License: MIT
• Homepage: https://wanshuiyin.github.io/ARIS-Movie-Director/comic/

Install and usage instructions live in the source repository linked above.