comic-author

name

comic-author

description

Phase 1 ORCHESTRATOR of a movie/comic — turn a fuzzy story idea into the Authored Source of Truth (a schema-valid comic.json + its locked asset library) by driving the detailed author skills in order (intent → style → outline → storyboard → assets → blueprints → prompts → comic.json), each gated by comic-cross-layer-gate, so comic-director (Phase 2/3) can bake + cross-model-verify it. You don't hand-write comic.json; this is the workflow your agent runs to author it. Use when the user says "做个漫画/电影", "from this idea make a comic", "author the comic.json", "run the comic pipeline".

comic-author — the Pipeline-A Orchestrator (Phase 1)

The left third of Figure 1, as an agent-run workflow: a fuzzy idea → a comic.json + its locked asset library, so comic-director (Phase 2/3) bakes + adversarially verifies it. This skill is thin — it owns the ORDER, the BARRIERS, and the HAND-OFF; each step's real procedure lives in its own detailed skill.

End-to-end in one slash-command? movie-pipeline is the single entry that drives THIS skill (Phase 1) → the p0_proof gate → comic-director (Phase 2/3 bake) → viewer. comic-author is the Phase-1 half it calls; use it directly when you only want to author + lock the comic.json. The contract boundary to Phase 2/3 is comic.json + the assets it references (content-SVG blueprints, identity refs, ART_BIBLE.md).

How you "run" this — it is an AGENT workflow, not a shell CLI. You point your coding agent (Claude, Codex, …) at this skill; the agent FOLLOWS the steps below — authoring the wiki nodes and calling the few deterministic helper scripts that ARE real CLIs: comic-director/scripts/run_comic.py, cli/validate_wiki.py, comic-panel-prompt-builder/scripts/build_prompt.py. The --gate <kind> notations below are the agent PROCEDURE in comic-cross-layer-gate (fan out the cross-model reviewers → fuse → flip status) — not a binary you exec. This mirrors every ARIS skill: the SOP is the product, a coding agent is the runtime.

Two hard human gates (never auto-proceed): the intent and the outline are story decisions — the user must approve each before the next layer starts (the story-first rule; the gate is acceptance-gate). Everything downstream is agent-driven + cross-model gated.

The pipeline (run in order) — the N1 two-stage DAG (each step = a detailed skill + its gate)

Dependencies are the node_schema source_* fields, not invented — each step consumes the prior locked node. The two-stage shape is the deadlock fix: the outline gate demands every referenced asset_id be DECLARED with a complete, generatable request (never locked — assets don't exist yet on a fresh project); the storyboard runs a provisional structural pass first; the ONE hard locked-asset barrier sits before blueprint authoring (step 7), reached via two cheap gate re-passes (6a/6b).

#	Step → skill	Produces	Gate (via comic-cross-layer-gate)
1	comic-intent-parser	intent_spec	USER approves → --gate intent
2	comic-style-bible-lock	style_anchor×N + ART_BIBLE.md	style lock (design-aware)
3	comic-outline-creator	outline_spec (3-lens → synth)	OUTLINE_DRAFT_VALID (--gate outline: narrative+continuity+safety; asset_ids DECLARED, not locked) → USER approves → locked
4	comic-storyboard-creator	PROVISIONAL storyboard_spec + panel_spec×N + motif_ledger + consolidated asset_requests	--gate storyboard structural pass (may reference draft assets)
5	comic-asset-ref-generator	asset×N (single-source, from the requests)	—
6	comic-asset-review-loop	each asset → status: locked (准×3)	--gate asset · assets LOCKED
6a	OUTLINE_FINAL_LOCK (gate re-pass, no new skill)	outline re-check decision node	cheap re-check: the locked assets still match the approved outline (identity/scene_lock_feasibility scored HERE)
6b	storyboard FINAL validation (gate re-pass)	storyboard_spec → locked	re-run --gate storyboard: panel_assets_referenceable (resolves AND locked) now satisfiable · ASSET-LOCK BARRIER ↓
7	comic-blueprint-author	blueprint×N (content-SVG, no baked bubbles)	--gate blueprint (the locked-asset HARD barrier lives here)
8	comic-panel-prompt-builder	prompt_bundle×N (搬运工原則)	build asserts: literal / zero-text / ref-count
9	comic-json-compiler	comic.json (authored fields only)	--gate compile (run_comic --dry-run + validate_wiki)

Entry/exit contract per step (what each consumes → hands off):

#	Entry	Exit
1	the user's fuzzy idea	locked intent_spec
2	intent_spec	locked ART_BIBLE.md + style_anchor×N
3	intent_spec (+ its skeleton)	locked, user-approved outline_spec (motif arcs + declared asset_ids)
4	locked outline_spec	provisional storyboard_spec / panel_spec×N / motif_ledger + consolidated asset_requests
5	consolidated asset_requests + ART_BIBLE.md	draft asset×N (files + nodes)
6	draft asset×N	locked asset×N
6a/6b	approved outline + provisional storyboard + locked assets	outline re-check decision node → locked storyboard_spec
7	panel_spec.content_blueprint + locked assets	locked blueprint×N
8	blueprints + panel_specs + ART_BIBLE.md	prompt_bundle×N
9	every locked layer	comic.json + compile decision node

Two services woven across the pipeline (not sequential steps):

• comic-cross-layer-gate — the ONE score-fuser every --gate <kind> above calls. Never invoked cold: each step first fans out its cross-model reviewers (writes review:* nodes + reviews edges), THEN calls the gate to fuse + flip status (locked on advance, rejected on a terminal fail; revise/regenerate/fallback are verdicts, never statuses). Reviewer routing: the Codex CLI at xhigh (it pins NO model — it follows the local codex config, currently gpt-5.6-sol) ‖ (Gemini auto-gemini-3 when available) — a different model family from this Claude author, paths only.
• comic-continuity-audit — authors the motif_ledger invariants in step 4 and runs as --gate continuity against that ledger (and at bake time inside the engine): DDL monotonic-down, bounce-single-max, metric-columns-disjoint, design-aware (absence ≠ drift).

The barriers (fail-closed — do not cross early)

1. Story approval — do NOT author the outline before the user approves the intent; do NOT author the storyboard before the user approves the outline.
2. ASSET-LOCK BARRIER (before step 7, blueprint authoring) — every asset a panel references must be status: locked before any blueprint is authored; a blueprint/panel referencing a draft asset is a hard veto. This is the ONE place the locked-asset demand lands (why the single-source asset library + 准×3 finish before any per-panel blueprint). Steps 6a/6b are its approach ramp: OUTLINE_FINAL_LOCK re-checks the approved outline against the now-locked assets, then the FINAL --gate storyboard re-run satisfies panel_assets_referenceable and flips the storyboard locked.
3. ZERO-CREDIT P0 SPENDING GATE (after step 9, before ANY bake) — the --gate p0_proof procedure: the agent fans out ≥2 cross-model reviewers over the compiled comic.json + the pipeline machinery, each writing a review JSON ({family, verdict, blockers[], comic_sha}); the deterministic MINTER comic-cross-layer-gate/scripts/run_p0_proof.py then verifies FAIL-CLOSED that BOTH non-author families {openai, google} PASS with blockers == [] on the SAME comic.json digest (parseable ≠ quorum; a missing/unparseable/timed-out review never counts) and atomically mints decision:p0_proof_* (verdict advance, digest-bound comic_sha + bake_plan_sha). run_comic.py's _p0_clean REJECTS a cert with missing/stale digests — a post-mint comic.json edit fail-closes the bake.

Hand-off to Phase 2/3

When comic.json validates, --gate compile passes, and the digest-bound decision:p0_proof_* cert is minted, Phase 1 is done. Then comic-director bakes + verifies:

python3 skills/comic-director/scripts/run_comic.py --project examples/<name> --page <P> --panels S01,S02 --dry-run

--dry-run first (it prints concrete bake prompts + literals, spends nothing — also how this skill confirms Phase 1 is correct). The REAL bake is not "just drop --dry-run": it runs --bake-mode=agent (the default) and needs a running agent wrapper servicing the mcp__codex__codex sidecar (.bakereq/.bakestatus

• pickup) — see comic-director's "Who runs --bake-mode=agent"; the exec path RAISES (retired). Honest model split: the BAKE pins gpt-5.5 + xhigh as the single compat default in run_comic.get_bake_plan() (the p0 cert digests it; a config-driven override is PLANNED, not yet implemented); the Codex CLI reviewers pin NO model (local codex config, currently gpt-5.6-sol) at xhigh. After ship, optionally comic-blind-comparison-review runs a double-blind A/B vs a naive one-shot baseline to prove the pipeline earned its cost.

Two engine contracts to author to (fail-closed)

1. Every panel needs a condition.content_svg (a deterministic blueprint SVG — figure or scene-anchor layout). condition.content_svg: null is rejected by the engine.
2. A text_mode:"baked" figure-panel must declare condition.expected_literals (exact numbers/keys, verbatim, ascii-tokenizable) — or the run is refused. A scene panel with no audited numbers → text_mode:"html".

Worked examples (the copy targets)

• The author-node fixture — examples/comic_min_author/: ONE valid node of each of the 10 author types (intent_spec → … → blueprint + prompt_bundle + motif_ledger + continuity_constraint) + the author-layer wiki/edges.jsonl + a real content_svg / identity .png / ART_BIBLE.md with STYLE_PREFIX. This is what you copy when authoring — python3 cli/validate_wiki.py examples/comic_min_author PASSES and build_prompt.py … panel:demo_s01 RUNS against it.
• The full reference run — examples/comic_m3_audit/ is the real authored source of truth this pipeline produced: story/OUTLINE_DRAFT.md (3-lens → codex synth → user-approved) · story/STORYBOARD_DRAFT.md (page order + the MOTIF STATE TABLE) · ART_BIBLE.md · gen/ (the asset + blueprint generator scripts) · comic.json · wiki/ (the full runtime node/edge trace). The detailed layer→skill index is references/authored_source_of_truth.md; field mapping is references/comic_authoring.md. Your authoring agent can be any coding agent (e.g. the ARIS main project) — this skill is self-contained and does not depend on it at runtime.

Protocols (governance contracts this orchestrator honors)

• acceptance-gate — each layer's gate can DRIVE but can't ACQUIT; the user is the hard gate for intent + outline; a different model family (the gate's Codex adjudicator) acquits the rest.
• artifact-integrity — the agent that authors a layer never judges its own layer's correctness; the cross-layer gate (a different family) does.
• reviewer-independence — every gate's reviewer gets file paths + an === EXTERNAL CONTEXT (advisory) === fence, never the author's interpretation.
• reviewer-routing — Codex reviewers at xhigh, NO model pin (local codex config, currently gpt-5.6-sol); Gemini auto-gemini-3 when available; never downgrade the effort tier.
• review-tracing · output-versioning · resumable-runs · external-cadence — trace every gate; version asset refs (_v{NNN} + supersedes); the orchestrator is resumable + its scheduled runs are fenced.