--gate intent|outline|asset|storyboard|blueprint|continuity|p0_proof|compile. A single fuser (not a per-layer split) prevents drift. It NEVER re-runs a reviewer; it collects the reviewer score-nodes already on the wiki (via reviews edges), fuses them deterministically (min-fuse per dim, max for inverted dims, SKIP missing dims — never substitute 0), then a Codex xhigh adjudicator (NO model pin — follows the local codex config) that sees ONLY structured inputs (scores + tags + raw artifact PATHS + verbatim source context + verbatim rubric — NEVER reviewer prose) makes an asymmetric call (threshold HARD-vetoes \"advance\"; Codex SOFT-vetoes everything else). The --gate p0_proof mode is the zero-credit pre-production proof: a text-only cross-model adversarial review of the pipeline's CODE + IR-CONTRACT + ENGINE state-machine that MUST clear all blockers in BOTH non-author families and then MINT the digest-bound decision:p0_proof certificate via scripts/run_p0_proof.py BEFORE a single metered image-generation credit is spent. Use when a sibling step (intent-parser, outline-creator, asset-review-loop, storyboard-creator, blueprint-author, continuity-audit, json-compiler) defers its acquittal to \"the gate\", or the user says \"过 gate\", \"cross-layer gate\", \"审这一层\", \"p0 proof\", \"证明流水线再花钱\".The acquittal organ of the comic-author suite. Every authoring step\n(intent → style → outline → asset → storyboard → blueprint → continuity → the compiled comic.json) is a\ngenerator; none of them acquits itself. They each emit their node(s), fan out independent reviewers, and\nthen defer to this one skill to fuse the scores into a verdict, mint the audit trail, and flip the target's\nstatus. It is the image-comic port of aris_movie's 6-gate adversarial decision skill — but folded into one\nparameterized fuser (Codex's single-fuser design, against the per-layer split that drifts: six near-copies\ndiverge, one fuser stays honest). The downstream per-panel panel_gate / page assembly_gate are NOT this\nskill — those live in packages/core/spiral_engine.js and run at bake\ntime; this skill is the authoring-side, pre-bake gate that decides whether a spec may advance.
\n\nCardinal lesson, landed as a guard not prose: identical scores across rounds = the judge is broken —\naudit the rubric, do not regenerate the artifact (memory:
\nfeedback_gate_identical_scores_judge_broken).\nConcretely: this gate carries a_score_fingerprintin everydecisionnode; if round N's fused per-dim\nvector equals round N−1's after the artifact changed, the gate HALTS and flagsjudge_suspect—\nthe rubric (this skill), not the spec, is the suspect. A gate that emits the same verdict regardless of the\nwork is worse than no gate.
upstream step emits node(s) + fans out independent reviewers (writes review:* score-nodes + `reviews` edges)\n │\n comic-cross-layer-gate <target_node_id> --gate <kind>\n ▼\n ⓪ PRE-CHECK structural facts the GATE computes (asset-resolve / policy / count-band / continuity) — RAW, not opinion\n ▼\n ① COLLECT reviewer score-nodes via `reviews` edges — NEVER re-run a reviewer; hard-fail if none\n ▼\n ② THRESHOLD per-dim min-fuse (max for inverted dims); SKIP missing dims (NEVER 0-substitute); per-gate floor → threshold_verdict\n ▼\n ③ ADJUDICATE Codex xhigh (no model pin — local codex config) — sees ONLY {scores + failure_mode tags + threshold_block + raw PATHS + ≤200w verbatim source + verbatim rubric}\n ▼ (NEVER reviewer prose / notes / overall — that is the contamination vector)\n ④ ASYMMETRIC threshold HARD-VETO over \"advance\"; Codex SOFT-VETO over everything else\n ▼\n ⑤ WRITE decision node (full audit) + (on FAIL only) a positive-invariant failure_mode the NEXT step preloads as a banlist\n ▼\n ⑥ FLIP target status → locked (advance) · under_review (needs-work) · rejected (terminal) ; stdout last line: VERDICT=<v> GATE=<kind> TARGET=<id>\nThe --gate p0_proof branch is a different shape (a text-only adversarial review of the pipeline machinery,\nnot a score-fuse over a spec) — it is documented in its own section below. It is the single most important\ncontract this skill owns: it runs AFTER comic-json-compiler and\nBEFORE any metered image bake (the agent mcp__codex__codex sidecar), costs zero generation credits,\nand must clear all blockers in BOTH non-author families and then MINT the digest-bound decision:p0_proof_*\ncertificate via scripts/run_p0_proof.py — or the spiral is forbidden to spend a\ncredit.
intent | outline | asset | storyboard | blueprint | continuity | p0_proof | compile. The\nlegal verdict set is per-gate (below) and enforced — a verdict outside a gate's set is a hard error (the\nintent gate can never emit keep; the asset gate can emit locked, the intent gate cannot). The legal\nnode 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.model_reasoning_effort: xhigh with NO\nmodel pin — it follows the local codex config (currently gpt-5.6-sol) — for every gate's ambiguity /\ncorrectness / logic pass; Gemini auto-gemini-3 wherever a second family or a visual read is needed\n(image inputs, UX/design). Never downgrade the effort tier\n(reviewer-routing). (The one place a model IS pinned is the\nmetered BAKE, not this skill: gpt-5.5 + xhigh as the single compat default in\nrun_comic.get_bake_plan() — config-driven override plumbing is planned, not yet implemented.)xhigh (same no-model-pin rule — local codex config), fed ONLY\nstructured inputs (§③). Its effort is always xhigh — effort widens fan-out, it never weakens the judge.\n(run_comic.py exposes only --review-effort; there is no --effort flag.)artifact_severity,\n*_severity, anything where higher = worse) use max; SKIP a dim no reviewer scored (filter the\nnulls) — NEVER substitute 0 (the v1.0 bug: a lite reviewer leaving a dim unscored must neither slip an\nadvance nor force a fail).approve/locked if the deterministic floor failed); Codex has SOFT VETO over everything else (a Codex\nrevise overrules a threshold approve). Structural facts (§⓪) also hard-veto advance.MAX_ASSET_REGEN = 4 then escalate the asset gate to the outline gate (abandon_shot);\nre-gate (re-vote) caps fold into the calling step's attempt budget. The 准 ×3 convention (asset gate,\nowned by comic-asset-review-loop): a locked verdict requires\ncross-model UNANIMITY in the SAME round — CC and Gemini and Codex all approve the asset that round\n(≥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\n\"three consecutive rounds\" — that aris_movie video port is wrong for this repo; the owner is same-round unanimity.)blockers.length == 0 in BOTH non-author families {openai, google} on the SAME\ncomic_sha, then the certificate is MINTED by scripts/run_p0_proof.py — a\nHARD HALT until the digest-bound decision:p0_proof_* node exists (a timed-out/missing family does NOT\ncount toward quorum; quorum unmet = no certificate = baking stays blocked). Zero image-generation credits\nare spent before the mint. The review is deliberately text-only → not rate-limited → free._confidence: \"low\", exit code\n2, and skip failure_mode compilation. Malformed adjudicator JSON → codex-reply retry ×2, then fall\nback to threshold-only.decision node in wiki/nodes/, the decides edge, a review-tracing entry per collected\nreviewer + the adjudicator, and (on a FAIL verdict only) a failure_mode node. Final stdout line is\nEXACTLY VERDICT=<v> GATE=<kind> TARGET=<id> for the caller to parse.The direct input is a target_node_id + a --gate <kind>. The gate reads from the wiki, it is not\nhanded prose:
review:* score-nodes with\nreviews edges → the target. The gate collects those nodes; if zero reviews are attached, it\nhard-fails (no reviews — gate is a score-fuser, not a reviewer). This is the load-bearing separation:\nthe executor that authored the spec must not also be the one whose read of it acquits it.notes, evidence,\noverall_assessment, or rationale (reviewer-independence).\nReviewer prose is the contamination vector; forwarding it re-introduces the correlated blind spot\ncross-model review exists to break. (Structural facts in §⓪ are an exception — they are RAW artifacts the\ngate itself computed, not reviewer opinion, so forwarding them does not violate independence.)verdict ∈ {approve, locked, revise, regenerate, fallback} (plus the\nasset-gate-only abandon_shot). Each reviewer call that feeds this gate gets file paths + an explicit\n=== EXTERNAL CONTEXT (advisory) === fence around any cross-cutting context — never the author's\ninterpretation. The fence is what keeps \"here is the situation\" from becoming \"here is what to conclude\".--gate except p0_proof — which has its OWN write path, the deterministic minter, §p0_proof below)Ported verbatim from the aris_movie 6-gate skill; the deterministic-JS fuse pattern is the same one the engine\nalready proves in packages/core/spiral_engine.js:59 (panelVerdict).
\n\nHonesty note: the six universal score-fuse gates ship NO runner today — the agent executes this SOP\ndirectly (collect → fuse → adjudicate → write → flip, by hand, per the steps below); a parameterized\n
\nrun_gate.pyis planned, not shipped. The only executables this skill owns/shells today are\nscripts/run_p0_proof.py(the p0 certificate minter) and the deterministic\n--gate compilescripts. The worked-example workflows below are the pattern to copy.
Before touching reviewers, compute the raw artifacts (filesystem facts, not opinions) the gate hard-vetoes\non. These differ per gate (see each rubric) but the shape is constant: resolve every referenced asset_id,\nevery asset is status: locked, policy fields match expected, count in band, continuity links\nwell-formed (no dangling / out-of-order / cycle). Any non-empty violation set → revise regardless of\nreviewer scores OR Codex (\"structural failures cannot be voted-around\"). Record each as\n_unresolved_asset_refs / _policy_violations / _count_band / _continuity_breaks in the decision audit.
Walk reviews edges into target_node_id; load each review:* node's payload.review_scores. Build\nper_reviewer = {reviewer: {dim: score, ...}, failure_mode_tags: [...]}. Hard-fail if the set is empty.
For each rubric dimension, fuse across reviewers with min (or max for an inverted dim), skipping\nany 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\nfresh reviewer can re-derive it from the table alone.
Call the Codex CLI at xhigh (no model pin — local codex config) with EXACTLY: per_reviewer scores, failure_mode_tags, the threshold_block\n(the fused values + the floor), the raw artifact PATHS, a ≤200-word verbatim slice of the source node\n(not a summary — a literal excerpt), and the verbatim rubric for this gate. Ask for a verdict in this\ngate's legal set + a one-line confidence + the single most important fix. Trace the call\n(review-tracing).
threshold_verdict == revise → the final verdict is a FAIL verdict no matter what Codex said (threshold\nhard-vetoes advance).threshold_verdict == advance AND Codex returns a FAIL verdict → Codex's FAIL wins (Codex soft-vetoes\nadvance).threshold_verdict == advance AND Codex advances → ADVANCE (approve / locked, per gate)._threshold_verdict, _codex_verdict, _disagreement (bool), _confidence.Write a decision node (full audit). On any FAIL verdict, compile one failure_mode node whose\nrepair_pattern is a POSITIVE INVARIANT (\"force a status:locked ref for every must_show asset\", NOT \"no\ndraft assets\") — diffusion and the next authoring step focus on what you mention, so state the desired\ntarget, not the ban (negative patterns are only for explicit banlists). Default scope is movie-local;\nengine-global needs explicit grounding (an over-broad failure_mode poisons cross-project banlists). The\nnext authoring step preloads this node as its banlist — the spiral's learning loop.
Flip target.status (locked on advance for asset/storyboard/etc.; leave/rejected on a terminal fail).\nException: a PROVISIONAL-stage storyboard approve never flips — the node stays under_review (see --gate storyboard). Append the decides edge. Print the parse line.
Every reviewer scores each dim 0–5. \"ADVANCE\" verdict in CAPS. Advisory dims do NOT block advance; they\nride into the decision audit and the adjudicator's context.
\n--gate intent → verdicts {approve, revise}APPROVE) iff completeness ≥ 4 AND safety_flag_coverage ≥ 4.clarity, scope_feasibility.intent_spec.payload.confidence < 0.6, OR any unresolved high-impact uncertainty\nremains, downgrade approve → revise even when both floor dims pass (low-confidence / unresolved intent must\nnot lock silently). This is the EXACT predicate comic-intent-parser must\nquote — no 0.5/0.6 drift between the parser's stated gate and the gate that actually runs.comic-intent-parser step ⑥ — this gate is the cross-model adjudication,\nnot the human sign-off.--gate outline → verdicts {approve, revise} — two checkpoints: OUTLINE_DRAFT_VALID, then OUTLINE_FINAL_LOCKThe outline acquittal is deliberately split in two. A single-stage \"outline needs locked assets\" contract\ndeadlocks a fresh project: assets are produced from the storyboard's consolidated_asset_requests, the\nstoryboard needs an approved outline, so the outline can never see a locked asset first. The Phase-1 DAG is:
OUTLINE_DRAFT_VALID → human outline approval → provisional storyboard (structural pass, may\nreference draft assets) → consolidated_asset_requests → asset generation + review → assets LOCKED →\nOUTLINE_FINAL_LOCK (cheap re-check) → storyboard FINAL asset-resolution validation → blueprints\nasset_id (scene / character / prop / must_show in the\n*_asset_ids lists) must be DECLARED with a complete, generatable request (enough spec for the asset\npipeline to produce it), else hard-fail with the missing-declaration list. Declared-but-draft is fine;\nundeclared or unrequestable is not.APPROVE) iff coverage ≥ 4 AND safety_ip ≥ 4.asset_promptability, audio_plan.identity_lock_feasibility ≥ 4 and scene_lock_feasibility ≥ 4 are\nscored (they are meaningless before real locked refs exist). The hard locked-asset barrier lives at the\nstoryboard FINAL asset-resolution validation + the blueprint gate, before blueprint authoring — not\nat the draft outline.--gate asset → verdicts {approve, regenerate, locked, abandon_shot}LOCKED) iff identity_lock_satisfied ≥ 4 AND ref_quality ≥ 4 AND bg_isolation ≥ 4\nAND safety_ip ≥ 4 — and the 准 ×3 rule holds (cross-model unanimity in the SAME round: CC AND\nGemini AND Codex all lock-pass that round; fewer than 3 families approving → regenerate --another-voter =\nre-vote to reach the third family, not re-bake; a family's hard-fail → re-bake). See Constants.reuse_readiness.output_ref exists on disk AND its sha256 matches the node AND the\ndata_url is non-empty — any mismatch hard-vetoes lock.MAX_ASSET_REGEN = 4 → escalate to the outline gate (abandon_shot).--gate storyboard → verdicts {approve, revise} — STRUCTURAL, CC-only (no visual reviewer; no pixels yet)This is the comic.json structural validator (it supersedes the lone check_asset_collisions.py) — and\nit is a TWO-STAGE contract: the gate runs TWICE per storyboard (the N1 DAG under --gate outline;\ncomic-storyboard-creator ⑨.0 quotes this same ordering):
panel_assets_referenceable is unscorable, left null, and the fuser SKIPs it (the\nverdict rides on the other three dims; only an UNDECLARED ref — no whitelist entry, no complete\nasset_request — vetoes). A provisional approve does NOT lock the storyboard node — no ⑥ FLIP; it\nstays under_review.locked; an un-locked\nref hard-vetoes via _unresolved_asset_refs), and approve flips the storyboard to locked on advance.The four structural dims are FILE-SYSTEM FACTS the gate computes, not reviewer opinion:
\npanel_assets_referenceable — every asset ref in each panel resolves and is locked. (Scored at\nthe FINAL stage only — the storyboard's FINAL asset-resolution validation, the hard locked-asset barrier\nof the Phase-1 DAG; at the PROVISIONAL stage it is null/SKIPped and the declared-check applies instead.)global_policies_valid — global_policies fields match expected (e.g. text-mode rules present;\nmirror-lock policy present; page-order authority declared).panel_count_band_aligned — panels-per-page in band per target tier {mvp:(2,2), demo:(4,6), longform:(10,12)} (in-range = 5, off-by-one = 3, further = ≤2), AND the TOTALS line reconciles (Σ\npanels-per-page == panel count; NEW + reused == total).continuity_chain_well_formed — the MOTIF STATE TABLE has one row per panel; links have no\ndangling / out-of-order / cycle; every per-panel motifs field agrees with its table row.APPROVE) iff ALL FOUR ≥ 4 — at the PROVISIONAL stage, all scorable dims\n(panel_assets_referenceable is SKIPped, never substituted with 0)._unresolved_asset_refs (FINAL stage; at the PROVISIONAL stage\ndeclared-but-unlocked refs are expected — only an UNDECLARED ref vetoes) / _policy_violations /\n_continuity_breaks, or an out-of-band _panel_count_band, forces revise regardless of reviewer scores\nOR Codex. (Plus the comic-specific structural vetoes the storyboard step also asks for: DDL\nnon-monotonic; bounce-uniqueness broken; the two metric columns co-mingling; a DONE panel retro-edited; the\nstoryboard page order disagreeing with the compiled comic.json page order — the storyboard is the\nauthority.)--gate blueprint (the IMAGE analog of aris_movie's frame_condition gate) → verdicts {approve, revise, fallback}aris_movie's frame_condition gate is VIDEO-flavored (action_freeze, harmonization); the IMAGE analog\ndrops the motion dims and asks instead: \"is this panel's condition.content_svg + identity_ref + scene\nbuildable?\"
APPROVE) iff refs_present ≥ 4 AND spatial_correctness ≥ 4 AND\nblueprint_renders ≥ 4 (the SVG rasterizes to a non-empty PNG — a RAW pre-check, not a vote).text_preservation required only when the panel has whitelisted baked text.safezone_quality (html panels) < 3 while the floor otherwise passes → fallback = route the\npanel's text to the HTML overlay (a route switch, not a regen).MAX_BLUEPRINT_REGEN = 3 → escalate to rewrite the panel_spec.--gate continuity → verdicts {approve, revise}Adjudicates the comic-continuity-audit read against the\nmotif_ledger. Dims (all ≥ 4 to ADVANCE):
ledger_row_complete — one MOTIF-table row per panel; no missing variable.invariants_hold — the declarative predicates verify against the table: ddl_monotonic_non_increasing,\nbounce_single_max (S02 = the film's ONLY MAX; no post-fall peak), metric_columns_disjoint (no\nclaim_delta value in the exact_parse column or vice-versa).mirror_locks_paired — each paired constraint (REJECT ↔ ACCEPT same stamp geometry; S02-MAX ↔\nS21-smallest; S16b labeled star-map ↔ S22 wordless twin from the same node JSON, 禁目测) is present and\nconsistent.design_aware — MOTIF-vs-ENV disambiguation is honored: only continuity-bearing instances are tracked;\nan intended absence / a tagged env prop is not flagged as drift (absence ≠ drift).revise (invariants are machine-checkable\npredicates, not vibes).--gate compile → verdicts {approve, revise} — DETERMINISTIC (no reviewer fan-out; the scripts ARE the judge)The compiled-comic.json acquittal that comic-json-compiler defers to.\nUnlike every other gate this one is purely deterministic — NO review:* nodes, NO Codex adjudication, so\n§① (collect) is skipped and the \"hard-fail if zero reviews\" rule does NOT apply. It PASSES (approve) iff\nboth real scripts exit 0, else revise carrying their stderr as the blocker list:
python3 skills/comic-director/scripts/run_comic.py --project <dir> --page <P> --panels <ids> --dry-run —\nvalidates the comic.json shape, that every text_mode:\"baked\" figure-panel carries ascii\ncondition.expected_literals, and prints each concrete bake prompt (no placeholders). --panels is\nrequired by run_comic.py (argparse required=True), so run this once per page in pages[] with that\npage's panel ids — omitting --panels exits non-zero (a false blocker).python3 cli/validate_wiki.py <dir> — node/edge/payload/privacy/node_id conformance against node_schema.json.\nThere is no reconcile_pages.py (it never existed) — these on-disk scripts are the entire deterministic\ncore. PASS (approve) iff EVERY per-page run_comic.py AND validate_wiki.py exit 0. Record all exit codes +\nany stderr in the decision audit. The §⑥ FLIP target is the schema-valid decision:compile_<slug> wiki node\nthis gate writes (status: final) — NOT comic.json, which is a file, not a wiki node (it has no legal\nnode_id prefix, carries no wiki_node_id, and can never be an edge endpoint).--gate p0_proof → verdict `The one gate whose decision node comes from a script: scripts/run_p0_proof.py\nmints verdict: advance after verifying the two-family same-digest quorum itself (full contract in the\ndedicated section below). Its target_node_id is the compile/intent anchor NODE (e.g.\ndecision:compile_<slug>) — never comic.json, which is a file, not a wiki node.
\n\nThe bake-time
\npanel_gate(spiral_engine.jspanelVerdict: KEEP iffnarr ≥ 4 AND minIdent ≥ 4 AND styleOK AND compOK AND NOT artifactBad AND textOK AND NOT anatomyDefect AND disagree < 2, where\nnarr = min(narrative_beat_fidelity, composition_story),artifactBadis corroborated — both visual\nreviewers must flag it, a lone pixel-purist cannot single-veto — anddisagreeis the two visual\nreviewers' identity-score gap) and the pageassembly_gateare NOT re-implemented here — they run at\nbake time insidepackages/core/spiral_engine.js. (Provenance\nnote: the engine's narrative \"cc\" reviewer slot currently shells the codex CLI and is honestly recorded as\nopenaiin the wiki; a configurable--narrative-revieweris planned, not yet implemented — cross-family\nacquittal vs the Claude author still holds via gemini + codex.) This skill is the authoring-side gate; the\nengine is the artifact-side gate. They share the same fuse discipline.
--gate p0_proof — the zero-credit code proof + the digest-bound spending certificateRuns AFTER comic-json-compiler, BEFORE any metered image\ngeneration. It is a text-only cross-model adversarial review of the pipeline machinery the executor\nauthored solo — distinct from experiment-integrity (audits results after the fact) and from the per-unit\npanel gate (audits generated artifacts). It is a pre-production correctness proof that is deliberately\nfree (text review, not image generation → not rate-limited). The fan-out shape is ported from\nexamples/comic_m3_audit/workflows/p0-review.js; the\ncertificate is minted by the shipped deterministic scripts/run_p0_proof.py — the\nagent never hand-writes the decision node.
Step 1 — compute the digest, fan out. comic_sha = sha256(<project>/comic.json BYTES). Fan out 3\nwatchdog-bounded CLI reviewers, each cat'ing the REAL files into its prompt (never a Claude summary), each\na DIFFERENT model family from the Claude author — and inject the comic_sha digest into every reviewer\nprompt with the instruction to echo it back in the review output; the echo is what binds each review to the\nexact compiled version it read:
codex on CODE — the build script + the viewer: base64 inlining, </ escaping in the JSON-in-<script>\nblob, missing-image handling, path resolution, the locale (T()) toggle, bubble positioning, XSS via\ninnerHTML of T(), ?p= bounds.codex on ENGINE LOGIC — spiral_engine.js: the panelVerdict formula (deadlock / wrong-keep /\nskip-missing-dim / disagree gate), the retry/rollback/caps state machine (infinite-loop risk, rollback\ntarget math, kept[] filtering, localByPanel reset), generatePanel's bake seam + the\ngen_failed/rate-limit path, the gate prompts eliciting parseable JSON, the REPO + \"/\" + REPO path\nhack, Promise.all races.gemini on DESIGN / CONTRACT / UX — is ART_BIBLE.md an executable convergence target for the\npanel_gate? Does the comic.json IR scale to 24 panels + bilingual + 3 text_modes? The viewer reading\nexperience? Drift from the design doc? (This google-family review may come from the legacy gemini CLI\nOR from Antigravity via the shipped shim, cli/gemini_agy_shim.py — the\nshim pins a Gemini model, so the family recorded stays google either way.)Gate schema FIND (required [reviewer, blockers, should_fix, overall]): blockers[] and should_fix[]\nare arrays of {file, issue, fix} — all three required per item (a blocker with no concrete fix is not a\nblocker, it is a complaint); plus nice[] and a one-line overall. Synthesis dedups, drops invalid/duplicate\npoints (noting the drop), orders BLOCKER > SHOULD > NICE, adds blocker_count / should_count, and\nreturns the single-most-important fix.
Step 2 — write one review JSON per family. From the CLEARED fan-out (every blocker fixed and re-reviewed)\nthe agent writes ≥2 review files, one per non-author family — e.g. p0_codex.json for openai,\np0_gemini.json for google — each carrying {family, verdict, blockers, comic_sha} (extra fields are\ntolerated; these four are what the minter checks). A review COUNTS toward quorum only if family ∈ {openai, google, anthropic}, blockers == [] (the literal empty list), verdict ∈ {pass, clean, approve, advance}, AND its comic_sha equals the digest of the CURRENT comic.json. Parseable alone is NOT\nquorum — a review that acquitted a different comic.json version, a non-empty blocker list, a missing file\n(reviewer timeout/skip) or unparseable JSON simply does not count. NEVER proceed on timeout: for this\ngate a timed-out family means quorum unmet, which means NO certificate, which means baking stays BLOCKED\n— fail-closed. (\"Note the timeout and proceed\" is legal ONLY for ADVISORY fan-outs, e.g. the pivot-design\nconsult — never for the spending gate.)
Step 3 — MINT the certificate (deterministic, fail-closed).
\npython3 skills/comic-cross-layer-gate/scripts/run_p0_proof.py \\\n --project <dir> --target <anchor_node_id> --reviews p0_codex.json p0_gemini.json\nThe minter re-verifies everything itself (it never trusts the agent's account of the fan-out): it recomputes\ncomic_sha from the comic.json BYTES, computes bake_plan_sha = pickup_image.bake_plan_digest(run_comic.get_bake_plan()) (the resolved bakereq/v1 spend plan —\nmodel/effort/include_image_gen_tool/sandbox/min_bytes/aspect/bake_timeout), discards every review that does\nnot count (stderr notes why), and requires BOTH non-author families {openai, google} among the counted\nreviews — the Claude author family can drive, never acquit. Any violation → clear stderr reason + exit 1 +\nno node. On success it atomically writes wiki/nodes/decision_p0_proof_<slug>_<utcstamp>.json:\nnode_id decision:p0_proof_<slug>_<utcstamp> (slug from comic.json comic_id), node_type: decision,\nstatus: final, real-UTC created_at, payload {gate_kind: p0_proof, verdict: advance, target_node_id, comic_sha, bake_plan_sha, reviewer_quorum, review_files}.
The legal p0_proof verdict is advance — minted by the script, never hand-written. What\nrun_comic.py's _p0_clean() preflight then verifies before spending a credit: a decision:p0_proof_* node\nwith gate_kind == p0_proof and an accepted status/verdict, AND payload.comic_sha == sha256 of the\nCURRENT comic.json AND payload.bake_plan_sha == the digest of get_bake_plan(args). Edit comic.json\nafter minting and the cert is stale → REJECTED (the log points back at run_p0_proof.py); the mint binds\nthe argparse-DEFAULT plan, so a run with non-default --min-bytes/--bake-timeout also needs a fresh cert.\nThis kills the \"a certificate once existed somewhere in this directory\" hole: the cert acquits ONLY the exact\nbytes + spend plan it audited.
(Operational hardening kept from the source: MCP is forbidden inside this fan-out — an unbounded hang\nwould freeze it — so every external call is a watchdog-bounded CLI: codex sleep 540-600s, gemini sleep 300-360s, kill -9 on timeout, unique temp file per branch. A killed reviewer simply produces no counted\nreview file — see step 2: no quorum, no cert, no spending.)
These mirror the engine's own fail-closed checks — cfgUsable (~L422) and generatePanel's content_svg\nshell-safety guard (~L273) in packages/core/spiral_engine.js — the\ngate refuses to ADVANCE a spec that would later make the engine refuse to run:
blueprint.payload.content_svg (top-level on the payload), the panel_spec.payload.content_blueprint\n(the panel_spec's own field — there is NO content_svg on a panel_spec), and the comic.json panel's\ncondition.content_svg (the RUNTIME field the engine reads at spiral_engine.js .condition.content_svg).\nAny of these null / empty / not a project-relative *.svg is a structural hard-veto at the blueprint\nand storyboard gates (the engine rejects condition.content_svg: null in comic.json outright). Do not let\na planned panel through with no blueprint.expected_literals (exact numbers / keys, verbatim, ASCII-\ntokenizable). The engine's cfgUsable refuses to run an ungated baked figure (a baked content_svg with\nan empty expected_literals is a fail-closed refusal). So the storyboard/blueprint gate hard-vetoes a\ntext_mode: \"baked\" figure-panel that carries no expected_literals; a scene panel with no audited\nnumbers must be text_mode: \"html\" (its text moves to the overlay). This is the plausible-unsupported-\nsuccess guard — a beautiful panel with a WRONG number must never keep, so the gate must be able to\ntoken-diff it later, which requires the literals authored now.schemas/node_schema.json)Reads:
\ntarget_node_id — one of intent_spec / outline_spec / asset / storyboard_spec /\nblueprint / (for continuity) motif_ledger / (for p0_proof) the compiled comic.json + pipeline\nfiles. Read its required payload (per the schema) — and a ≤200-word verbatim slice is the only source\ntext the adjudicator sees.review node attached via a reviews edge → the target. Required payload target_node_id, reviewer, gate_kind; the per-dim scores live in the optional review_scores map this skill fuses. (Edge\nreviews may carry the optional reviewer ∈ {cc, codex, gemini} + weight.)failure_mode nodes (so the adjudicator's context includes what already\nfailed at this layer).Writes (one JSON file each under wiki/nodes/, created_at ISO-8601):
decision (node_id decision:<gate>_<slug>) — payload required target_node_id, verdict, gate_kind; this skill additionally writes the audit fields _threshold_verdict, _codex_verdict, _disagreement, _confidence, _cited_dimensions, _score_fingerprint (+ the structural sets\n_unresolved_asset_refs / _policy_violations / _count_band / _continuity_breaks when computed). status: \"final\". Append a decides edge (decision → target, optional verdict on the edge).p0_proof decisions are never hand-written:\nscripts/run_p0_proof.py mints decision:p0_proof_<slug>_<utcstamp> (verdict\nadvance, status: final, payload adds comic_sha, bake_plan_sha, reviewer_quorum, review_files)\natomically, fail-closed, after verifying the two-family same-digest quorum itself. Every OTHER gate's\ndecision node is written by the agent per this section.failure_mode (node_id fail:<gate>_<slug>) — only on a FAIL verdict. Payload required\nlayer, affected_shot_ids, active; repair_pattern is the positive invariant; default scope\nmovie-local. status: \"active\". Append a failure_of edge (failure_mode → target).failure_mode on an advance verdict, and none when Codex was unavailable (provisional verdict).The canonical exhibits are the three historical orchestration scripts + the engine that ground this skill:
\nThe P0 proof — examples/comic_m3_audit/workflows/p0-review.js.\nCopy the FIND schema (required: ['reviewer','blockers','should_fix','overall'], each blocker/\nshould_fix item {file, issue, fix} — all three required), the 3-reviewer fan-out (codexReview('code', [BUILDER, TEMPLATE], …) ‖ codexReview('engine', [ENGINE], …) ‖ the inline gemini design reviewer), the\ncat-the-real-file rule (files.map(f => 'echo \"===== ${f} =====\"; cat \"${f}\"') — never a summary), and\nthe synthesis reducer that dedups → orders BLOCKER>SHOULD>NICE → returns blocker_count/should_count.\nIts watchdog hardening (codex … & P=$!; ( sleep 540; kill -9 $P ) & WD=$!; wait $P; kill $WD) is exactly\nthe MCP-forbidden discipline — but note where the LIVE contract diverges from the exhibit: p0-review.js\nnoted a timeout and proceeded; the shipped minter makes a timed-out family not count toward quorum, so\nthe spending gate stays blocked. The contract is blockers.length == 0 in both non-author families on\nthe same comic_sha, then the run_p0_proof.py mint, before any credit.
The cross-model adjudication shape — examples/comic_m3_audit/workflows/pivot-design.js.\nCopy the typed gate schemas that force the gate to be real: DESIGN_SCHEMA\n(required: ['recommendation','codex_take','gemini_take','open_decisions'] — a branch cannot claim a\ncross-model review it did not do, the codex_take/gemini_take fields are the evidence), and\nCRITIQUE_SCHEMA (required: ['model','biggest_flaws','missing','risks','verdict'], prompt forbids\nsoftening: \"pass through the sharpest valid points\"). The \"form your OWN take FIRST → get codex → get\ngemini → reconcile/judge → surface only genuine human forks\" loop is the adjudicator discipline; the\nunique temp file per branch + note-a-timeout-and-proceed is the operational guard — legal here\nbecause this consult is ADVISORY; the p0_proof spending gate must fail-closed on timeout instead.
The deterministic fuse — packages/core/spiral_engine.js:59 (panelVerdict).\nThis is the exact min-fuse / skip-missing / max-for-inverted / single-vote-veto pattern to port into §②:\nidents = [gem?..., cdx?...].filter(x => x != null); minIdent = idents.length ? Math.min(...idents) : 0\n(skip-missing, never 0-substitute when some reviewer scored it); artifactBad = (gemArt >= 4 && cdxArt >= 3) || … (inverted dim, corroborated — a lone pixel-purist can't single-veto a by-design background glow);\nanatomyDefect = … === true (a single-vote veto for a clear defect the literal-diff is blind to); and the\nfail-closed guard if (![gem,cdx].every(r => visCore(r).every(x => x != null))) return retry (a\nreviewer that returned incomplete core scores must not slip an advance). The authoring gate inherits this\nverbatim so reviewer-independence + min-fuse + positive-invariant failure_modes come for free.
review:* nodes the upstream\nstep already wrote; hard-fail if there are none. Re-running a reviewer here would make the gate part of\nthe thing it judges.reviewer-independence).SKIP a dim no reviewer scored — NEVER substitute 0. (The v1.0 bug: a lite reviewer's blank dim\nmust neither slip an advance nor force a fail.)--gate p0_proof to blockers.length == 0 in BOTH non-author families AND mint the cert via\nscripts/run_p0_proof.py BEFORE the first metered bake. It is free, and run_comic.py fail-closes\nwithout the digest-bound node. Skipping it to \"save a step\" trades zero-cost text review for credit-cost\nregeneration.judge_suspect; audit this rubric (memory:\nfeedback_gate_identical_scores_judge_broken). A gate that scores the same regardless of the work is broken.acceptance-gate).env prop, a deliberate absence are design, not drift. The gate is design-aware.intent gate cannot say keep; only the asset\ngate can say locked/abandon_shot) — it is a hard error.failure_mode on an advance, or when Codex was unavailable (the provisional verdict is\n_confidence: low, exit 2 — fix and re-gate, don't poison the banlist).p0_proof fan-out — watchdog-bounded CLI only. And DON'T treat a p0\ntimeout as skippable: a timed-out family does not count toward quorum → no certificate → baking stays\nblocked (fail-closed). Note-a-timeout-and-proceed is for ADVISORY fan-outs only.reviewer-independence — the adjudicator sees scores + tags +\nraw PATHS + a ≤200-word verbatim source slice + the verbatim rubric only; never reviewer prose/notes/\noverall. The p0_proof reviewers each cat the real files, never a Claude summary. The\n=== EXTERNAL CONTEXT (advisory) === fence keeps cross-cutting context from becoming a conclusion.acceptance-gate — this skill IS the acquittal: a generating step can\nDRIVE toward a locked spec but cannot ACQUIT it; a different model family (Codex adjudicator) + the\ndeterministic threshold do. Identical-scores-across-rounds → the judge is suspect, not the artifact.review-tracing — every collected reviewer + the adjudicator call + the\np0_proof fan-out is traced (prompt + response + threadId + verdict) so each acquittal is auditable and the\nindependence claim is checkable after the fact.reviewer-routing — the Codex CLI at xhigh with no model pin (it\nfollows the local codex config, currently gpt-5.6-sol) for the adjudicator and every correctness/logic\nreviewer; Gemini auto-gemini-3 for the visual/design family; the metered bake alone pins gpt-5.5 +\nxhigh in run_comic.get_bake_plan() (single compat default; config-driven override is planned). Never\ndowngrade the effort tier (effort widens fan-out, never weakens the judge).artifact-integrity — structural facts (asset-resolve / policy /\ncount-band / continuity / sha-match / blueprint-renders) are RAW artifacts the gate computes and hard-vetoes\non; they are verified, never originated, and forwarding them to Codex is not an independence breach.fan-out-pattern — the p0_proof 3-reviewer fan-out and the per-gate\nmulti-reviewer collection are Tier-1/Tier-2 fan-outs that converge on this one cross-model adjudication\nbench.injection-hygiene — all node ids / paths flowing into the\nwatchdog CLI prompts are whitelisted ([A-Za-z0-9_-] ids, absolute metachar-free paths) before\ninterpolation, exactly as the engine validates them.