# Comic Asset Review Loop > Phase-1 (S5) UPSTREAM ref-asset gate — the bounded cross-model adversarial loop that LOCKS one reusable identity-locked asset (character sheet / location plate / prop cutout / text-panel / logo-free symbol) BEFORE it can be composited into any panel. This is NOT the panel_gate (composed-output) or the assembly_gate (cross-panel) — it gates the refs that FEED both, so identity drift is caught at the source, not downstream. Two layers: (1) a MANDATORY static single-source collision check (check_asset_collisions.py — 'one visual dialect, never two', enforced by tool) + zero-text/literal build-asserts; (2) a per-round 3-reviewer panel (Claude narrative ‖ Gemini visual ‖ Codex synth) that blind-scores 5 dims and LOCKS only at 准×3 unanimity (prior_lock_count>=3 approvals in the SAME round) — else regenerate (route to comic-asset-ref-generator) or, at MAX_REVIEW_ROUNDS, escalate the asset REQUIREMENT back to outline/storyboard. Hard IP veto. Use when you say 'lock this character ref', 'asset gate', 'ref review', 'is - Skill: `wanshuiyin/comic-asset-review-loop` (Agent Skill) - Install (CLI): `npx skillmds@latest add wanshuiyin/comic-asset-review-loop` - Raw SKILL.md: https://api.skillmd.com/api/skills/wanshuiyin/comic-asset-review-loop/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Design & Media - Author: wanshuiyin (https://skillmd.com/u/wanshuiyin) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/wanshuiyin/comic-asset-review-loop --- # comic-asset-review-loop — the UPSTREAM ref gate (Phase 1 · S5) The **ref gate the comic side was missing.** `comic-director`'s `panel_gate` reviews *composed output*; the `assembly_gate` reviews *cross-panel consistency*. Neither gates the **identity refs that feed both** — so without this skill, identity drift is only caught *downstream*, after credits are spent on a panel bake. This skill is the **Layer-2 gate on a SINGLE reusable reference asset** (the character sheets / location plates / prop cutouts the `ART_BIBLE.md` points every bake at), run **before** any panel composition. A reusable asset is a one-way door: once a hundred panels condition on `duo_canonical_ref_v001.png`, you cannot quietly swap it. So the lock must be **earned cross-model**, never self-certified by the generator. This skill locks an asset **only at 准×3** — Claude *and* Gemini *and* Codex each independently pass the **same** review round — or it sends the asset back to be regenerated, or (at the round ceiling) escalates the asset *requirement* itself back to the outline/storyboard layer. The executor (and the generation model family) **never** acquit their own ref. **Pipeline position (the Phase-1 asset DAG — the documented contract):** this lock runs AFTER the human-approved outline (OUTLINE_DRAFT_VALID only requires every referenced asset to be DECLARED with a complete, generatable request — never pre-locked assets) and the **provisional** storyboard's `consolidated_asset_requests`, and BEFORE OUTLINE_FINAL_LOCK (cheap re-check that the locked assets still match the approved outline) → storyboard FINAL asset-resolution validation → blueprint authoring, where the hard locked-asset barrier sits. (The old single-stage contract — outline gate demanding locked assets — deadlocked and is retired.) ```text asset (review_status:"pending") ◀── comic-asset-ref-generator (S4: generates, NEVER self-locks) │ ▼ LAYER 1 — STATIC CI GATE (deterministic, zero credits) check_asset_collisions.py (one canonical owner per filename — "one visual dialect, never two") + build asserts: zero-text contract · literal contract · raster-ref 6-field completeness │ pass ▼ LAYER 2 — VISUAL LOOP (round R = 1 … MAX_REVIEW_ROUNDS=3) ① Claude narrative ‖ ② Gemini visual (primary: identity/iso) ‖ ③ Codex synth (policy/semantic) each reads the REAL asset file · scores 5 dims (0–5 ints) · flags failure_modes from the fixed vocab │ ▼ Codex synthesises: MIN-fuse per dim (max for inverted) · threshold · per-reviewer unanimity 准×3 ? ── no, a family HARD-FAILS a floor ─▶ comic-asset-ref-generator --regenerate (bump version) ─▶ ① R+1 │ no, third family just ABSENT (e.g. Gemini down) ─▶ re-VOTE (re-collect the missing reviewer; NO re-bake) │ no (safety_ip<3) ─▶ HARD abandon_shot (IP veto, no retries) │ no (R == MAX_REVIEW_ROUNDS) ─▶ ESCALATE the asset REQUIREMENT to outline/storyboard (abandon_shot) │ yes ▼ LOCK — asset.status=locked + payload.review_status=locked (ONE-WAY DOOR, immutable for the rest of Phase 1) + score_progression audit table (ASSET_REVIEW.md) + decision/review/failure_mode wiki nodes + edges ``` ## Constants - **REVIEWERS** = Claude (this agent, narrative) ‖ `mcp__gemini__analyzeFile` (`model: "auto-gemini-3"`, NEVER raw `gemini-3.1-pro` — 429 silent-downgrade to 2.5) ‖ `mcp__codex__codex` r1 / `mcp__codex__codex-reply` r2+ (`model_reasoning_effort: "xhigh"`, save the `threadId`; pin **no** model — Codex reviewer calls follow the local codex config, currently `gpt-5.6-sol`, exactly like the shipped Codex CLI reviewers in `run_comic.py`, which pass no `-m`; only the upstream BAKE payload pins `gpt-5.5` + `xhigh`, the `run_comic.get_bake_plan()` compat default — a config-driven override there is planned, not yet implemented). - **准×3 UNANIMITY** — the lock predicate. A Codex-synth `approve` is **NOT** enough: `cc_approves AND gemini_approves AND codex_approves` must ALL be true **in the same round** (each reviewer's *own* dim scores must independently clear threshold). Codex-approve-without-unanimity is **DOWNGRADED to `revise`** (the "准×3 bite"). `prior_lock_count` = the count of approvals accumulated this round; **lock iff prior_lock_count >= 3**. - **MAX_REVIEW_ROUNDS** = 3 (hard ceiling). Even if Codex keeps saying `regenerate`, the loop STOPS at 3 and routes back to outline/storyboard — the *requirement* changes; the gate does not grind an image forever. - **CROSS-MODEL ACQUITTAL** — Codex is the **synth/policy** reviewer and (in the broader pipeline) the generation family for raster refs. A Codex `approve` can *diagnose/veto* but is **never the sole acquitter**; the lock needs Gemini approve + Claude approve too (acceptance-gate.md: the loop DRIVES, it can't ACQUIT). - **SAFETY_IP SINGLE-VOTE VETO** — `safety_ip < 3` from **ANY** reviewer = immediate HARD `abandon_shot`, no retries (generalises `comic-director`'s anatomy single-vote veto to IP/likeness). - **`--lite` is NON-ACQUITTING** — when Gemini is unavailable it may set only a PROVISIONAL `status: under_review` (tag `lite_provisional: true`), **NEVER a root `status: locked`.** The one-way LOCK requires the THIRD family (Gemini) to lock-pass in a later round: 准×3 is CC AND Gemini AND Codex same-round unanimity (canon), and the only sanctioned relaxation is the gate's "a model is UNAVAILABLE → threshold-only PROVISIONAL, exit 2" — never a Gemini-absent lock. Use `--lite` only to keep progress while Gemini is down; never the default; it can never write the locked one-way door. - **OUTPUT** = `examples//story/ASSET_REVIEW.md` (the human score-progression audit) + wiki nodes/edges under `wiki/nodes/` + per-reviewer trace under `.aris/traces/comic-asset-review-loop/`. ## Input contract / what this skill owns The contract boundary is the **`asset` wiki node** authored by [`comic-asset-ref-generator`](../comic-asset-ref-generator/SKILL.md) (S4) at `review_status: "pending"` — generated, never self-locked. This skill is **pure verify + lock**: - It **never edits the asset's pixels or geometry** — on `regenerate`/`revise` it routes a ≤140-char `repair_instruction` back to S4, which bumps the version and emits a new file. - It **never invents** scores or a verdict on behalf of an absent reviewer — a dim no reviewer scored is `not_scored` and **EXCLUDED** from the threshold, never substituted with 0 (the v1.0 bug; see Hard do/don't). - It writes back **only** `status: "locked"` + `payload.review_status: "locked"` on a 准×3 approve, plus the review/decision/failure_mode trace. `locked` is the one-way door — immutable for the rest of Phase 1. **Read** the `asset` node payload (per `schemas/node_schema.json`, `node_type: "asset"`, `payload.required = [asset_kind, name, visual_description, identity_lock, ref_requirements, review_status, version]`): - `asset_kind` ∈ {character, scene, prop, text_panel, logo_free_symbol} — **routes the per-reviewer query** (see §"Asset-kind specialisation"). - `identity_lock.{must_preserve[], must_avoid[]}` — the per-asset rubric (e.g. from `ART_BIBLE.md` §1: executor = blue hoodie `#1D4684` + brown hair + **no beard**; reviewer = green hoodie `#30582D` + near-black hair + **beard**; "颜色/胡子/体型轮廓不可变"). - `ref_requirements.{aspect_ratio, background (white|transparent), pose, isolated_reference}`. - `output_ref.{file_path, data_url, sha256, width, height, mime}` for a raster ref (all 6 fields, else schema violation) **OR** `{generator_script, owner_script, file_sha256}` for a deterministic SVG/JSON source. ## The EXACT gate (ported from `asset-review-loop`) ### Layer 1 — static CI gate (deterministic, MANDATORY, zero credits) Run **before** any visual reviewer call (and re-run before lock). Fail-closed; correctness costs no credits. - **single-source collision check** — `check_asset_collisions.py` static-scans every `gen_*.py` with the regex `\bw\(\s*["']([^"']+\.(?:svg|json|png))["']` and asserts **each output filename has EXACTLY ONE generator owner**. `len(writers) > 1` → `exit 1`. This is the tool that enforces **"one visual dialect, never two"**: two generators writing the same path with different content is a silent, run-order-dependent corruption (whoever runs last wins). It is deliberately **NOT** a "skip if file exists" guard — that would *hide* the order bug instead of surfacing it. Verdict: `exit 0` (clean) is a **precondition** for entering Layer 2; `exit 1` blocks the round and routes to S4 to rename/delete the duplicate. (Verified clean at 26 outputs in the worked example.) - **zero-text contract** — for any asset that must contain no glyphs (e.g. the S22 constellation): `assert " **These are THIS skill's pre-gate routing thresholds (the asset-gate step-3 routing this skill OWNS), and > they are written to MATCH [`comic-cross-layer-gate`](../comic-cross-layer-gate/SKILL.md)'s `--gate asset` > LOCK predicate verbatim.** The gate's `LOCKED` condition is `identity_lock_satisfied >= 4 AND ref_quality >= 4 > AND bg_isolation >= 4 AND safety_ip >= 4` **AND** the `准 ×3` same-round cross-model unanimity rule — > `reuse_readiness` is **ADVISORY** at the gate and does **not** block the lock. The `approve` rule below uses > exactly those four floors; `reuse_readiness` only feeds `revise`/`regenerate` routing, never blocks the lock. Codex **MIN-fuses** each dim across the reviewers who scored it (the gate's deterministic rule: **min** per dim, **max** for an inverted dim, single scorer → use it, NO scorer → `not_scored` **EXCLUDE** — **never 0-substitute, never average**: averaging `{5,3}`→4 would slip a sub-floor ref past the `>=4` lock; min=3 correctly fails). So this inline routing can only be **stricter**, never weaker, than `--gate asset`. The legal asset verdict set is `{approve, regenerate, locked, abandon_shot}` (gate-enforced); the internal `revise` below is an alias that routes a `regenerate`. Then: - **`approve`** ← `identity_lock_satisfied >= 4` **AND** `ref_quality >= 4` **AND** `bg_isolation >= 4` **AND** `safety_ip >= 4` (the four gate floors). **`asset_kind == "character"` override:** `identity_lock_satisfied == 5` is REQUIRED (a raster character ref locks only at a *perfect* identity score — 4 is not enough for a face hundreds of panels condition on); the other three floors stay `>= 4`. (准×3 same-round unanimity still applies on top — see the LOCK note below.) - **`regenerate`** ← `identity_lock_satisfied < 4` (or `< 5` for a character) OR `bg_isolation < 4` OR `ref_quality < 4` OR `safety_ip ∈ [3, 4)` OR `reuse_readiness < 3` (advisory: routes a regen hint, does not itself block a lock that already clears the four floors). - **`revise`** ← mid-band, a single targeted edit likely fixes it (softer hint, still routes a `regenerate` with a focused `repair_instruction`). - **`abandon_shot`** ← `safety_ip < 3` (HARD STOP, IP) **OR** `round >= MAX_REVIEW_ROUNDS` without convergence. > **Deterministic-SVG / JSON asset branch** (a parametric builder, NOT a raster ref → the visual 5-dim rubric > does not apply). A deterministic-SVG source **locks iff ALL FOUR hold** (Layer-1 asserts + a 3-dim 0–5 read): > `single_source_owner == pass` (Layer-1 `check_asset_collisions.py` exit 0 — exactly one generator owns the > filename) **AND** `render_preview_legible >= 4` (the SVG/JSON rasterizes to a non-empty, on-spec preview PNG — > a RAW render pre-check, not a vote) **AND** `literal_contract >= 4` (the `_contract` field is honored: literals > are ascii-tokenizable, the JSON is the single coordinate truth, no eyeball re-layout) **AND** > `style_family_consistency >= 4` (one visual dialect — palette/stroke/grid match the `ART_BIBLE.md` family). > Plus the **zero-text / non-gated-text asserts**: a wordless source contains no `` (`assert " in svg`); a labeled source's glyphs are exactly the contract's literals. Same 准×3 same-round unanimity gates > the SVG lock as the raster lock. (Gemini PRIMARY on `render_preview_legible` + `style_family_consistency`; > Codex PRIMARY on `literal_contract`; `single_source_owner` is the Layer-1 tool, not a reviewer vote.) > **LOCK requires 准×3 UNANIMITY, not Codex-synth-approve.** Even on a Codex `approve`, the lock fires **iff** > `cc_approves AND gemini_approves AND codex_approves` in the **same** round (each reviewer's own 5 scores > independently clear the per-reviewer thresholds — including the `identity_lock_satisfied == 5` floor for a > character ref / the four-dim SVG floors for a deterministic source). A Codex `approve` with any reviewer below > threshold is **DOWNGRADED to `revise`**. (`--lite` is **non-acquitting**: with Gemini absent it may only write > provisional `status: under_review` + `lite_provisional: true`, and can NEVER satisfy the LOCK predicate or reach P6.) This same-round > unanimity rule is exactly [`comic-cross-layer-gate`](../comic-cross-layer-gate/SKILL.md)'s `准 ×3` for > `--gate asset` (this skill is the OWNER of that convention) — NOT "three consecutive rounds". ### Veto rules (hard, non-negotiable) - **safety_ip < 3 from ANY reviewer → immediate `abandon_shot`** (single-vote IP veto, no retries). - **Layer-1 fail (collision / missing literal / partial raster / zero-text breach) → block the round**, route to S4, do not enter Layer 2. - **round >= MAX_REVIEW_ROUNDS without 准×3 → ESCALATE the asset *requirement*** to [`comic-outline-creator`](../comic-outline-creator/SKILL.md) / [`comic-storyboard-creator`](../comic-storyboard-creator/SKILL.md) (the spec/outline must change; stop re-baking the image). Mutual recursion is bounded by this ceiling. ### Controlled failure-mode vocabulary (the FIXED set reviewers draw tags from) `face_drift, age_drift, costume_drift, pose_off, multi_subject_leak, halo_artifact, shadow_spill, non_white_bg, jpeg_artifact, glyph_break, unintended_text, watermark_present, contact_sheet, celeb_likeness, copyrighted_character, brand_logo_present, collage_grid, low_resolution, melted_anatomy`. Every reject mints a `failure_mode` wiki node `fail:_` tagged from this set (the `` must match `[a-z0-9_]+` — strip any stray punctuation before assembling the node_id; maps to `comic-director`'s anatomy/identity vetoes) and routes its tag into the S4 `repair_instruction`. The node MUST carry the schema-required shape (copy the `fail:*` skeleton in "Wiki node skeletons" below **verbatim**): root `status: "active"` + payload `{layer, affected_shot_ids, active, repair_pattern}`. Because this is an **upstream asset gate with no shots yet**, `affected_shot_ids` is `[]` (empty) — never invented. NB the shipped example failure nodes are FILES named `fail_*.json` (the colon lives only inside the `node_id`, e.g. `fail:s09_a01`) and are ALL downstream shot-level nodes (`layer:"panel_visual"`, non-empty `affected_shot_ids` — `fail_s09_a01.json` carries `["S09"]`); **no asset_ref-layer example exists in the repo**, so do NOT copy the example nodes for this gate — the skeleton below is the authoritative shape. ## Wiki node skeletons (the EXACT shape each minted node MUST carry — validated by `cli/validate_wiki.py`) Every node this skill writes obeys `schemas/node_schema.json`: the **root** carries `node_id, node_type, title, status, created_at, payload` (all six required), the `node_id` matches `^(…|review|decision|fail):[a-z0-9_-]+$`, and the `payload` carries every field in `validate_wiki.py` `PAYLOAD_REQUIRED` for that type. The canonical root `status` for each runtime type (schema $comment; the real example nodes carry exactly these): `review → "complete"`, `decision → "final"`, `failure_mode → "active"`. Copy these skeletons verbatim: ```jsonc // review:* — one per reviewer per round (P1 cc, P2 gemini, P3 codex). node_id: review:__round{R} // PAYLOAD_REQUIRED["review"] = [target_node_id, reviewer, gate_kind] (review_scores carries the 5 dims) { "node_id": "review:duo_canonical_ref_v001_cc_round1", "node_type": "review", "status": "complete", "title": "CC narrative asset review duo_canonical_ref v1 r1", "created_at": "", "payload": { "target_node_id": "asset:", "reviewer": "cc", "gate_kind": "asset", "review_scores": { "identity_lock_satisfied": 5, "ref_quality": 4, "bg_isolation": 4, "reuse_readiness": 4, "safety_ip": 5 }, "failure_modes_flagged": [], "timed_out": false } } // decision:* — one per round after the synth+准×3 (P4). node_id: decision:asset__round{R} // PAYLOAD_REQUIRED["decision"] = [target_node_id, verdict, gate_kind] { "node_id": "decision:asset_duo_canonical_ref_v001_round1", "node_type": "decision", "status": "final", "title": "asset_gate duo_canonical_ref v1 r1 -> locked", "created_at": "", "payload": { "target_node_id": "asset:", "gate_kind": "asset", "verdict": "approve", "reasoning": "LOCK 准×3 — identity=5 ref=4 bg=4 safety=5 reuse=4; cc&gemini&codex approve r1", "repair_instruction": "", "prior_lock_count": 3 } } // fail:* — only on a reject/abandon_shot (P0 Layer-1 fail, P2 parse failure-mode, P5 reject). node_id: fail:_ // PAYLOAD_REQUIRED["failure_mode"] = [layer, affected_shot_ids, active] (upstream gate → affected_shot_ids: []) { "node_id": "fail:duo_canonical_ref_v001_costume_drift", "node_type": "failure_mode", "status": "active", "title": "asset_gate duo_canonical_ref costume_drift", "created_at": "", "payload": { "layer": "asset_ref", "affected_shot_ids": [], "active": true, "repair_pattern": "executor 蓝衣棕发无须 (must_preserve); 当前绿衣漂移 — 重生为 #1D4684 hoodie" } } ``` After any lock (P6), run `python3 cli/validate_wiki.py examples/` — it MUST PASS (root status enum, node_id form, payload invariants). A node missing root `status` or `target_node_id` / `layer` / `affected_shot_ids` / `active` is the exact failure the validator catches. ## The two fail-closed engine contracts (where they bite here) This is an **upstream** gate, so it enforces the *preconditions* the downstream engine fail-closes on. **Do NOT conflate the three SVG fields** (per `schemas/node_schema.json` + the engine): the wiki `blueprint.payload.content_svg` (top-level on the blueprint payload), the `panel_spec.payload.content_blueprint` (the panel_spec's own field — there is NO `content_svg` on a panel_spec), and the **comic.json** panel's **runtime** `condition.content_svg` (the field the engine reads at `spiral_engine.js` `.condition.content_svg`). 1. **Every panel needs a renderable blueprint SVG.** A locked asset is only useful if a panel can condition on it — so when locking a deterministic SVG/JSON source, verify it rasterizes to a non-empty PNG (a `blueprint` node would carry it as `blueprint.payload.content_svg`), because at bake time the engine **refuses** a comic.json panel whose `condition.content_svg` is `null`/absent. A ref that cannot become a content-SVG condition is not "reuse-ready" — score `reuse_readiness` (and, for an SVG source, `render_preview_legible`) accordingly. **Never `condition.content_svg: null`.** 2. **A baked figure-panel needs `condition.expected_literals`.** If the asset is a **text_panel** / figure source whose downstream panels bake numbers (e.g. a wandb curve, a verdict stamp, a DDL widget), its lock MUST verify the literal contract holds (the literals are ascii-tokenizable and the JSON `_contract` forbids eyeball re-layout) — because `comic-director`'s gate **refuses to run** a baked figure-panel whose comic.json `condition.expected_literals` is empty. Locking a figure source that cannot supply gateable literals would strand the panel; a scene panel with no audited numbers takes `text_mode: "html"` instead. ## Numbered procedure (per round R, start R = 1, loop until 准×3 or R = 3) **P0 — Resolve + Layer-1 gate.** Resolve the target `asset` node (single `asset_id`, or fan out one branch per asset under `--batch-from-outline`). Assert `review_status == "pending"`; **abort if already `locked`** (one-way door). Route by `asset_kind` (visual raster kinds → the raster 5-dim branch; a deterministic SVG/JSON source → the SVG 4-dim branch; an audio kind would take the audio branch — out of scope for the comic). **Run Layer 1** (`check_asset_collisions.py` + build-asserts + raster 6-field check); on any failure, write a `failure_mode` node (root `status: "active"`, payload `{layer:"asset_ref", affected_shot_ids:[], active:true, repair_pattern: }` per the `fail:*` skeleton) + a `failure_of` edge `fail:<…> → asset:`, route to S4, and stop — do not spend a visual reviewer call. **P1 — Claude narrative review.** `Read` the PNG (image bytes). Score all 5 dims (Claude **PRIMARY** on `reuse_readiness`; Codex is PRIMARY on `safety_ip` per the rubric), emit `failure_modes_flagged[]` (from the fixed vocab) + `narrative_notes`. Write a review-stage scratch JSON and a wiki `review` node `review:_cc_round{R}` with **root `status: "complete"`** and payload carrying the three PAYLOAD_REQUIRED fields **`target_node_id: "asset:"`, `reviewer: "cc"`, `gate_kind: "asset"`** plus `review_scores` keyed by the 5 dims (see the `review:*` skeleton above). Append a **`reviews`** edge `review:<…> → asset:` (review → target — the direction the gate walks; NEVER `reviewed_by`). **Atomic write** (`.tmp` → `mv`). **P2 — Gemini visual review** (skip iff `--lite`). Call `mcp__gemini__analyzeFile` with `model: "auto-gemini-3"` (NEVER raw `gemini-3.1-pro`), the PNG path, and a **strict-JSON-only** template that asks for the 5 dim scores (Gemini **PRIMARY** on `identity_lock_satisfied`, `ref_quality`, `bg_isolation`) + `failure_modes` drawn from the fixed vocab. **Retry once** on non-JSON, then log a `gemini_parse_failure` and treat those scores as `null` (not 0). Optional focused follow-up if `identity_lock_satisfied < 3`. Write the `review` node `review:_gemini_round{R}` with **root `status: "complete"`** and payload **`target_node_id: "asset:"`, `reviewer: "gemini"`, `gate_kind: "asset"`** + `review_scores`; append the **`reviews`** edge `review:<…> → asset:` (review → target). On a parse failure mint a `fail:*` node per the `fail:*` skeleton (root `status: "active"`, payload `{layer:"asset_ref", affected_shot_ids:[], active:true, repair_pattern:"gemini_parse_failure — re-elicit strict JSON"}`). **P3 — Codex synth gate.** `mcp__codex__codex` (r1) / `mcp__codex__codex-reply` (r2+ with the saved `threadId`), effort `xhigh`, no model pin (follows the local codex config — currently `gpt-5.6-sol`). Pass **ONLY** numeric scores + `failure_modes` + `asset_metadata` + file paths + (optional) numeric prior-round deltas — **NEVER** any reviewer `narrative_notes`/prose (reviewer-independence; a prose leak ABORTS the call with a loud error). Codex adds its OWN `safety_ip` (PRIMARY) + semantic `identity_lock_satisfied` + `reuse_readiness` scores. **First persist Codex's OWN reviewer node** (mirroring P1 cc / P2 gemini): `review:_codex_round{R}` (root `status: "complete"`, payload `{target_node_id: "asset:", reviewer: "codex", gate_kind: "asset", review_scores: {the 5 dims Codex scored}}`) + a `reviews` edge `review:<…>_codex_round{R} → asset:` — so all THREE reviewer families exist as first-class collected nodes (准×3 needs Codex as one of the three the gate walks). THEN synthesise: **MIN-fuse** each dim across the reviewers who scored it (max for an inverted dim; single scorer → use it; no scorer → `not_scored`, EXCLUDE — never average / 0-substitute) → `verdict` + `per_reviewer_unanimity{cc,gemini,codex}` + `repair_instruction` (≤140 chars) + `rationale` (≤300 chars — the ONLY Codex prose allowed out). **P4 — Apply threshold + 准×3 → `decision` node.** Apply the threshold, then the unanimity downgrade. Write a `decision` node `decision:asset__round{R}` with **root `status: "final"`** and payload carrying the three PAYLOAD_REQUIRED fields **`target_node_id: "asset:"`, `verdict`, `gate_kind: "asset"`** plus `reasoning`, `repair_instruction`, `prior_lock_count` (see the `decision:*` skeleton above). `approve` + `prior_lock_count >= 3` (准×3) → mark **lock**. `approve` without unanimity → downgrade to `revise`, which is **persisted as `verdict: regenerate`** — the only legal `decision.payload.verdict` tokens are `{approve, regenerate, locked, abandon_shot}` (a verdict outside the gate's set is a hard error); `revise` is an internal route label kept in `reasoning`/`repair_instruction`, never written as the verdict. A TERMINAL fail — `abandon_shot` (IP veto) OR the `R == MAX_REVIEW_ROUNDS` escalation (P5) — sets **BOTH** root `asset.status: "rejected"` AND `payload.review_status: "rejected"` (canon D2/D3: terminal-fail → root `status` rejected; mirror the lock path, which sets both). A non-terminal `revise`/`regenerate` keeps root `status: "under_review"` (provisional), never leaving an abandoned asset stuck at `pending`. > **Gate handoff (this skill is the asset gate's review-producer).** P1–P3 have now persisted the `review:*` > score-nodes + `reviews` edges that [`comic-cross-layer-gate`](../comic-cross-layer-gate/SKILL.md) `--gate > asset` collects — so the gate is **never invoked cold**. This skill runs the asset-gate synthesis inline (it > OWNS 准×3); when the orchestrator defers acquittal to `comic-cross-layer-gate > --gate > asset` instead, it fuses the SAME `review:*` nodes via those `reviews` edges and re-derives the `>=4`-floor + > 准×3 verdict. NOTE this skill applies an ADDITIONAL stricter pre-gate floor (character > `identity_lock_satisfied == 5`; the deterministic-SVG 4-dim branch for an identity-4 ref), so its inline > verdict can be **stricter** (never weaker) than the bare gate's `>=4` floor — the deferred gate does not > reproduce the `==5` character rejection byte-for-byte. The `decides` edge (P5) links this `decision` → the asset. **P5 — Edges + route.** Write edges using ONLY `validate_wiki.py` `EDGE_TYPES`: a **`reviews`** edge `review:<…> → asset:` per reviewer (review → target — the direction `--gate asset` walks; NEVER `reviewed_by`, the opposite direction, which the gate cannot follow), the **`decides`** edge `decision:asset_<…> → asset:`, and on a reject/abandon_shot a **`failure_of`** edge `{src: "fail:_", dst: "asset:", type: "failure_of"}` (failure_mode → target, matching the real `examples/comic_m3_audit/wiki/edges.jsonl`). A regen that supersedes the prior version writes a **`supersedes`** edge `asset: → asset:` (bare node_ids, no `@vN`). Then route: - **third family merely ABSENT this round** (a reviewer didn't vote — e.g. Gemini down, or `--lite`) and NO family hard-failed a floor → **RE-VOTE**: re-collect ONLY the missing reviewer (re-run that one family); do **NOT** `--regenerate` (re-baking wastes a credit when the image is fine and only the third vote is missing). - `regenerate`/`revise` (a family HARD-FAILED a floor) **and R < 3** → call [`comic-asset-ref-generator`](../comic-asset-ref-generator/SKILL.md) `--regenerate` with the `repair_instruction` (it bumps the version, emits a new PNG with a `supersedes` self-edge, re-fires at **R+1**). - `regenerate`/`revise` **and the re-bake count reaches `MAX_ASSET_REGEN` = 4** (the gate's re-bake cap, [`comic-cross-layer-gate`](../comic-cross-layer-gate/SKILL.md) lines 70/184 — a SEPARATE ceiling from this skill's own `MAX_REVIEW_ROUNDS = 3` visual review-round limit; either hitting its ceiling escalates) → force **`abandon_shot`** → **ESCALATE the requirement** to outline/storyboard. - `abandon_shot` (IP) → exit immediately. **P6 — Lock** (on `approve` + full 准×3 = CC AND Gemini AND Codex same-round unanimity). Set `status: "locked"` + `payload.review_status: "locked"`; append tags `[asset_gate_locked, round_{R}_approve]`. (**`--lite` can NOT reach P6** — with Gemini down it stays provisional `under_review`, never locked.) Validate against `schemas/node_schema.json` (`python3 cli/validate_wiki.py examples/`); append a `log.md` line; write the final **`ASSET_REVIEW.md` score_progression** table (the human audit trail — *why* it locked at r2 vs r3 vs abandoned). **Lock = ONE-WAY DOOR**, immutable for the rest of the pipeline. ## Asset-kind specialisation (drives the per-reviewer query) - **character** → identity_lock weights face/age/hair/costume/**beard** (the `ART_BIBLE.md` §1 iron law: executor never bearded, reviewer always bearded; colours immutable, L/R position free). - **scene** → `bg_isolation` becomes **scene_emptiness** (a location plate must carry no characters/props). - **prop** → standard 5 dims; `bg_isolation` weighted (clean cutout, no spill). - **text_panel** → glyph crispness weighted into `ref_quality` (maps to `comic-director`'s `baked_text_quality`); the literal contract (engine contract #2) is checked at lock. - **logo_free_symbol** → **extra `safety_ip` weight** (the symbol must not resemble a real brand mark). ## The judge-is-broken guard (battle lesson — land it, don't just say it) **IDENTICAL scores across review rounds mean the rubric/judge is broken — STOP regenerating and audit the judge.** If round R and round R+1 (on a *regenerated* asset) return the **same** per-dim vector from the same reviewer, the artifact changed but the score did not → the **rubric** (not the asset) is wrong. Concretely: - **Detect**: after P4 on R+1, compare the per-reviewer dim vectors to round R's. If `cc`/`gemini`/`codex` return a byte-identical 5-vector on a *new* file (different `sha256`), **flag `judge_stuck`**. - **Halt the bake**: do NOT route another `--regenerate`. Two identical rounds is the ceiling for *grinding* even before MAX_REVIEW_ROUNDS. - **Audit the judge** instead: re-read `identity_lock.{must_preserve,must_avoid}` and the `ART_BIBLE.md` carve- outs — is the gate flagging a **by-design** trait as drift? (The classic: the two-world warm/dark palette is *intentional* — `ART_BIBLE.md` §0.5 "冷暖是 by-design 的,不是漂移"; a naive gate scores it "style drift" every round. The `motif`-vs-`env` disambiguation is the same lesson: the gate must know which instances are continuity-bearing.) Fix the rubric (sharpen the per-dim definition / add the carve-out to the reviewer query), record it as a `decision` trace node, then resume. **A stuck score is a judge bug, not an asset bug.** ## Worked example Ground every run in the real M3-audit comic asset set under `examples/comic_m3_audit/` (repo-relative). The exact patterns to copy: - **Layer-1 collision gate** — `gen/check_asset_collisions.py` (41 lines) is the single-source CI gate verbatim: the `WRITE = re.compile(r'\bw\(\s*["']([^"']+\.(?:svg|json|png))["']')` scan over every `gen_*.py`, the `len(writers) > 1` collision rule, the `exit 0/1` contract, and the load-bearing comment that it is **deliberately NOT** a "skip if the file already exists" guard ("that would HIDE the order bug instead of surfacing it"). Its message — *"Each asset must have ONE canonical owner ('one visual dialect, never two')"* — is the literal embodiment of this skill's single-source rule. **Verified clean at 26 outputs (exit 0).** Run this as Layer 1 of P0; do not enter Layer 2 until it returns 0. - **The identity-lock rubric** — `ART_BIBLE.md` §1 (`角色身份锁`) is the literal `must_preserve`/`must_avoid` source for an `identity_lock_satisfied` score: authority ref `duo_canonical_ref_v001.png`; per-character hex table (executor blue hoodie `#1D4684` / brown hair `#925935` / **NO beard**; reviewer green hoodie `#30582D` / near-black hair `#0F0D16` / **beard**); the 铁律 *"executor 永远蓝+棕发+无须;reviewer 永远绿+黑发+有须 … 颜色/胡子/体型轮廓不可变"*. A Gemini visual reviewer cat's the PNG and scores it against **this** — not by vibes. §0.5 (the warm/dark two-world palette, *"冷暖是 by-design 的,不是漂移"*) is the canonical carve-out for the judge-is-broken guard above. §7 FORBIDDEN (no smooth gradients on character surfaces, no voxel, no non-canonical mascot colours, no off-identity beard) is the `must_avoid` list. - **The P0-blocker pattern** — `story/STORYBOARD_DRAFT.md` flags `researcher_chibi_canonical_ref_v001.png` as **missing** (only the duo had a canonical ref). That is exactly the state this gate must catch *before* any panel bakes the researcher: a raster ref with no file is not lockable (Layer-1 raster 6-field check fails); it routes to S4 to generate the ref, and only then does Layer 2 run. **Copy this:** a panel that conditions on a ref whose asset node is not `locked` is a pre-bake blocker, surfaced here, never discovered downstream. Pattern to copy end-to-end: **Layer 1 (deterministic, free) gates single-source + completeness → Layer 2 (cross-model, metered only after L1 passes) gates the 5 dims against the `ART_BIBLE.md` rubric → lock at 准×3 or route back to S4 (regenerate) / outline (escalate).** ## Hard do / don't (earned lessons) - **DO** run the static collision gate (`check_asset_collisions.py`) as Layer 1 of **every** run, before any reviewer call — "one visual dialect, never two" is enforced by the tool, not by prose. - **DO** lock **only at 准×3**: Claude AND Gemini AND Codex pass the SAME round. A Codex-synth `approve` alone downgrades to `revise`. The generator family never self-acquits its own ref. - **DO** treat `safety_ip < 3` from **any one** reviewer as an immediate hard `abandon_shot` — IP is a single-vote veto, no retries (the same shape as the anatomy single-vote veto). - **DO** stop at MAX_REVIEW_ROUNDS=3 and escalate the asset **requirement** to outline/storyboard — the spec changes; the gate does not grind one image forever. - **DON'T** zero a missing dim. A dim no reviewer scored is `not_scored` and **EXCLUDED** from the threshold — substituting 0 was the v1.0 bug that mis-rejected good refs. - **DON'T** keep regenerating when rounds return **identical** scores on a *changed* file — that means the **judge** is broken (a by-design trait scored as drift). Audit the rubric, not the asset. - **DON'T** leak reviewer prose into the Codex synth call — pass numeric scores + failure_modes + paths only; a prose leak ABORTS the gate (reviewer-independence). - **DON'T** edit the asset's pixels here. On `regenerate`/`revise`, route a ≤140-char `repair_instruction` to `comic-asset-ref-generator`; this skill only verifies and locks. - **DON'T** re-open a `locked` asset — the lock is a one-way door; a later need for a different ref is a NEW asset (new file, `supersedes` edge), not an edit of the locked one. ## Scope | Target | Fit | |---|---| | reusable character sheet / location plate / prop cutout (identity-locked raster ref) | **excellent** | | deterministic SVG/JSON asset source (one parametric builder per recurring motif) | **excellent** | | text_panel / figure source whose downstream panels bake gateable literals | good (checks the literal contract) | | logo-free symbol / mark (extra safety_ip weight) | good | | a *composed* panel's faithfulness | no → that's `comic-director`'s `panel_gate` | | cross-panel continuity (motif drift across the film) | no → that's `comic-continuity-audit` / the assembly_gate | ## Protocols (governance contracts this skill honors) - [`reviewer-independence`](../../protocols/reviewer-independence.md) — each reviewer reads the real asset file; the Codex synth gets **numeric scores + failure_modes + paths only**, never another reviewer's prose (a leak ABORTS). - [`acceptance-gate`](../../protocols/acceptance-gate.md) — the loop DRIVES (regenerate, re-fire R+1) but can't ACQUIT: the LOCK is a Type-B verdict that needs 准×3 (Gemini + Codex + Claude in the same round); Codex-synth-approve alone is downgraded; same-family N-of-Claude is never a jury. - [`review-tracing`](../../protocols/review-tracing.md) — every Codex/Gemini reviewer call's full prompt+response is saved under `.aris/traces/comic-asset-review-loop/_run/`, so each lock/abandon_shot verdict is auditable; the `ASSET_REVIEW.md` score_progression is the human-readable trail. - [`reviewer-routing`](../../protocols/reviewer-routing.md) — Codex reviewer calls pin **no** model (local codex config — currently `gpt-5.6-sol`) at effort `xhigh` (only the upstream bake payload pins `gpt-5.5` + `xhigh`, the `run_comic.get_bake_plan()` compat default; config-driven override planned); Gemini `auto-gemini-3` (never raw `gemini-3.1-pro`); `— reviewer: oracle-pro` routes the synth to `mcp__oracle__consult` (the Pro tier) on explicit request; never downgrade the tier.