comic-outline-creator — the Outline + Motif Contract (Phase 1, Layer 2)

The middle-left of Figure 1: take a locked intent_spec (+ the pre-locked beat/shot skeleton it carries — OR, for an idea-first comic with NO pre-locked skeleton, the 3 lenses first synthesize a beat skeleton from the intent's logline / subjects / constraints / format, then adapt it the same way; the synthesized skeleton is recorded so the deltas-vs-skeleton discipline still applies) and produce a single approved outline_spec — the 6-column beat table that drives the storyboard, and the continuity-motif arcs that become the storyboard's checkable contract. This is the comic twin of aris_movie's movie-outline-creator (a Layer-2 authoring-time plan gate before any pixels), specialized for our image-comic route: the deliverable is a plan, never a frame.

Two things are simultaneously true, and the whole skill is built around them: (a) the outline is NOT a free brainstorm — it is an editorial adaptation of a pre-locked skeleton (N beats / M shots, beat boundaries fixed), so every candidate must self-report its deltas vs the skeleton; (b) an unbounded "ARIS capability showcase" silently rots into a product manual unless every capability is bound to a concrete story cost and skill-name tags are banned from the 画面. The 3-lens → Codex-synthesis → density-pass → user-approval loop turns (a) into a faithful, debated outline and the 侧栏讲解铁律 + the gate catch (b) every round.

  intent_spec (logline + tagline + dual-identity + LOCKED skeleton)
        │
        ▼  ① FAN-OUT: 3 parallel named lenses over the SAME skeleton (faithful ∥ comicnative ∥ clarity)
        │     each ends with a self-authored "through-line + deltas vs the skeleton" section
        ▼
  ② SYNTHESIZE — Codex (different model family) reconciles the 3 → OUTLINE v2
        ▼
  ③ DENSITY/DESIGN pass — Codex MAY restructure panel count (e.g. centerpiece 4→5 pages, +mid-act page)
        │     AUTHORS the 侧栏讲解铁律 (anti "product manual" guard)
        ▼
  ④ Emit the 6-column BEAT TABLE + the centerpiece sub-plan + the 5 motif arcs (exact per-shot values)
        ▼
  ⑤ READINESS gate (PRE-user, cross-model, blind to orchestrator prose) — scores ONLY the author-controllable
        │   dims; EXCLUDES user_decision_record + the unresolved-questions veto (those are not yet satisfiable).
        │   Two-step (never cold): write review:* nodes + `reviews` edges → THEN comic-cross-layer-gate <id> --gate outline
        ▼ readiness:advance
  ⑥ USER APPROVAL = HARD GATE — present; record ✅ APPROVED + fill 已定决策 + EMPTY 待确认 block
        │   THEN the FINAL gate (now user_decision_record==5 IS satisfiable) → write outline_spec node (locked)
        │ revise ─▶ ② (bounded: MAX_OUTLINE_REVISIONS=3 → auto-abandon → failure_mode node)
        ▼ approve + signed
  outline_spec (locked) → SOURCE OF TRUTH for the storyboard layer
        │
        ▼  (much later, orchestrator-owned) OUTLINE_FINAL_LOCK — after the asset layer locks, a cheap
           re-check that the locked assets still match this approved outline (N1 two-stage; §EXACT gate)

Constants

• LENS_COUNT = 3, mandatory (faithful, comicnative, clarity) — Tier-1 Workflow fan-out (fan-out-pattern). Fewer than 3 lenses is a hard veto.
• SYNTHESIZER = mcp__codex__codex, model_reasoning_effort: xhigh — a different model family from the Claude lens authors. Codex both reconciles the 3 candidates AND runs the density/restructure pass; the outline layer is itself a cross-model artifact (executor ≠ reviewer, reviewer-independence).
• GATE REVIEWERS = mcp__codex__codex (NO model pin — follows the local codex config, currently gpt-5.6-sol — at xhigh) ‖ Gemini (auto-gemini-3, readability dims) — each sees ONLY outline_spec.json + intent_spec.json (the skeleton) + the lens files, never Claude's prose. They do not acquit; they each persist a review:<slug> node (payload {target_node_id, reviewer, gate_kind: "outline", review_scores:{...}}) with a reviews edge review:<slug> → <outline_id>, and the SOLE acquittal organ comic-cross-layer-gate --gate outline then fuses those score-nodes (D4: never invoke the gate cold — write the reviews FIRST, then call the gate).
• THE GATE IS RUN TWICE BY THIS SKILL (the user-approval deadlock fix): a READINESS pass BEFORE user approval (scores only the author-controllable dims; the gate's own user_decision_record == 5 floor and the unresolved-questions veto are not yet satisfiable, so the readiness reviewers explicitly omit them), then the FINAL pass AFTER the user signs + the 待确认 block is emptied (now user_decision_record == 5 IS satisfiable). See §EXACT gate. A THIRD, later touch — OUTLINE_FINAL_LOCK — is owned by the orchestrator, not this skill: after the asset layer locks (provisional storyboard → asset gen/review), a cheap re-check that the locked assets still match the approved outline (§EXACT gate → the N1 two-stage contract).
• MAX_OUTLINE_REVISIONS = 3, then auto-abandon → write a failure_mode node so a re-run must diverge. Its payload is exactly what validate_wiki.py PAYLOAD_REQUIRED demands for failure_mode: {"layer": "outline", "affected_shot_ids": [<the abandoned skeleton shots, e.g. all S01..SMM>], "active": true} (node_id fail:<slug>, node_type failure_mode, status active). There is NO encoding_style field in the schema — carry the "a re-run must diverge" positive-invariant in title or a non-required note, never a fabricated required-looking key; the node must pass cli/validate_wiki.py.
• MAX_DRAFT_ATTEMPTS = 3 — schema-repair loop for the outline_spec node; on each fail, codex-reply quoting the validator errors verbatim. Never silently coerce a value to pass schema (change the narrative + document it, or surface to the user).
• TARGET_PAGE_CEILING (soft cap, exceed ⇒ Codex must justify in rationale.beat_count_justification, not a hard stop): mvp=2, demo=6, longform=12 beats per tier (ported from MAX_BEATS_PER_TIER).
• MIN_CAST_PER_BEAT = every beat names ≥1 world/scene + the cast in it (text-panel beats: a text-panel scene + its world). Ported from aris_movie's MIN_ASSETS_PER_BEAT=2; a structural check JSON-Schema can't express.
• NODE = outline_spec (this skill reads intent_spec, writes one outline_spec). See §Node.
• APPROVAL IS NON-AUTOMATABLE — the loop can DRIVE to a clean gate, but only the user ACQUITS the outline (acceptance-gate). Nothing proceeds to the storyboard layer until the user signs off, recorded inline.

Input contract — what this skill reads, what it must not invent

The contract boundary is the intent_spec node (§Node) — produced upstream by comic-intent-parser, carrying: the logline (a single sentence whose climax may be an editorial inversion — e.g. "the climax is NOT winning — it's that ARIS didn't let itself off the hook"); the tagline; the dual_identity constraint ("an emotional story of honest research + an ARIS capability showcase") the whole debate optimizes against; and the source_skeleton — the pre-locked beat list (B01…BNN), shot list (S01…SMM), and beat boundaries. The skeleton is LOCKED; this skill ADAPTS it, never re-derives it.

This skill is plan + verify: it never bakes a pixel (image gen is comic-director / Phase 2-3) and never invents a beat boundary or a shot. Adding a page (a density-pass split) is allowed and must be accounted for in the deltas; moving a beat boundary or dropping a shot is a delta that must be justified + surfaced to the user. If intent.status != locked → REFUSE (the upstream hand-off token is locked = approved + frozen; an under_review/draft intent is not ready — re-run comic-intent-parser to its user gate). If the skeleton is missing → REFUSE and ESCALATE (do not fabricate one).

Procedure (an agent can execute this step by step)

0. Load + refuse-guard

Snapshot the intent_spec node. Pull cumulative wiki context: prior LOCKED assets (for reuse-over-invention), and failure_mode nodes with layer="outline" (rejected/superseded outlines — a re-run must diverge from them). Refuse if intent.status != locked (the upstream author-node hand-off token is locked, not active). Checkpoint an OUTLINE_STATE.json (resumable — resumable-runs).

1. FAN-OUT — write 3 parallel candidate LENSES over the SAME locked skeleton

This is Tier-1 Workflow fan-out (fan-out-pattern): three independent passes, each a named lens over the identical skeleton, NOT three free drafts. Write each to its own file (story/outline_candidate_{faithful,comicnative,clarity}.md). The three lenses are fixed:

• faithful — one-to-one fidelity: M shots → M panels, no cut / merge / add, beat boundaries B01…BNN preserved exactly. The conservative anchor (palette grammar + stamp mirrors live here).
• comicnative — comic-as-a-medium: collapse runtime / motion shots into static-friendly pages (in our run S07-S09 → one 2×2 page; 22 shots → 12 panels); choose a full-bleed / 2-up / 2×2 page-rhythm for scroll-reading.
• clarity — legibility for a non-ML reader: foreground the through-line so the headline number-arc (in our run +6.2 → +1.4) is readable via one concrete physical prop (the Tok|yo broken-JSON evidence) + one wordless emotional gauge (executor bounce height).

Each candidate MUST end with a self-authored section: ## through-line + deltas vs the skeleton stating exactly what it merged / added / kept and why (e.g. "merged S07-S09 → one 2×2 page (motion is redundant in a static page); kept all 13 beats; moved Tok|yo's first plant earlier to B06-S09 as a re-pointable物证"). A candidate with no deltas section is a hard veto — delta-accounting is the discipline that proves it is an adaptation, not a guess.

2. SYNTHESIZE — Codex reconciles the 3 → OUTLINE v2

Call the SYNTHESIZER (different model family). Feed it the three lens files + the intent_spec + schemas/node_schema.json's outline_spec shape, inside a demarcated === EXTERNAL CONTEXT (advisory) === fence; Claude's prose lives ONLY in that fence (reviewer-independence). The synthesis takes the best of each lens — in our run: faithful's two-world WARM/DARK palette grammar

• the REJECT↔ACCEPT mirror, comicnative's page-rhythm, clarity's motif arcs + countdown spine. Emit {outline, rationale}.

3. DENSITY / DESIGN pass — Codex MAY restructure panel count

Codex then does a density / design pass that may materially change panel count where the read demands it (in our run: the centerpiece B08 went 4 panels → 5 single-read pages by adding an "audit entry" panel, with the 2×2 kept only as recap/hero/GitHub-screenshot; and a new mid-act page B09.5 "research star-map / wiki" was added after the audit, before the paper — flagged as "the most powerful position"; panel count moved 22 → ~24). This pass also AUTHORS the 侧栏讲解铁律 (step 6). Adding pages is fine; account for every one in the deltas.

4. Emit the 6-column BEAT TABLE

Emit the canonical table — fixed columns, in this order:

| Beat (zh/en) | Panels | 布局/layout | 世界/world | 内容 + 台词 gist | ARIS 特性（绑剧情）|

• Beat — bilingual id + name (**B01 卧室·倒计时**).
• Panels — the shot ids it OWNS (S01 · S07,S08,S09大 · S12-15 + 新增 S12a).
• 布局/layout token ∈ {full-bleed, split, 2-up, 1-panel, 竖排3, 5单张页(默认)/2×2 recap}.
• 世界/world token ∈ {暖/WARM, 暗/DARK, seam, 暗·星空/starfield} — human beats warm, ARIS beats dark-cyber, explicit seam panels at hand-off / payoff. (The warm/cold split is by-design — the downstream gate must never flag it as drift.)
• 内容 + 台词 gist — panel action + baked-dialogue gist + a one-line side-narration (旁白).
• ARIS 特性（绑剧情） — the bound capability, phrased as a STORY COST, never a feature name (✅ experiment-bridge（证据是暂定的） · honest re-run（自纠 overclaim） · auto-review-loop（对抗审）; ❌ experiment-audit, novelty-check as bare tags). A bare feature name here is a hard veto.

5. Centerpiece sub-plan (the densest beat)

For the centerpiece beat, emit a sub-table | 页/page | 画面/image | 侧栏（先讲发生了什么，再点能力）| with the verbatim 70/30 composition rule:

每页：技术主画面 70% + 角色情绪 30%（右下角蓝 exec bounce 当体温计）+ 侧栏讲解。

Each row's 侧栏 puts the event-sentence first, then · *trait: <skill>* second (so the side-narration reads as story, then footnotes the capability).

6. Embed VERBATIM the 侧栏讲解铁律 (the anti "product-manual" guard)

This block is load-bearing — copy it verbatim into the outline (it is what stops a capability showcase from rotting into a product manual):

🎙️ 侧栏讲解铁律（防止"能力展示"变产品手册 —— codex）

• 每条能力必须绑一个剧情代价：不写"ARIS has experiment-audit"，写"executor 的庆祝被审计打断，所以 ARIS 没撒谎"。
• 侧栏第一句永远讲发生了什么；第二句才点能力名。
• 每个能力都改变角色状态（bounce 高低 / 咖啡冷掉 / 红队介入 / claim 被降级）。
• 画面里不堆 skill 名标签；skill 名只作侧栏小字或 hover/click metadata。

7. Lock the continuity-motif arcs AT OUTLINE TIME (exact per-shot values)

The outline doubles as the continuity contract — the storyboard's motif-state table and the panel/assembly gates will be checked against these arcs, so they must carry exact per-shot values now. Lock the 5 arcs (our run's values, as the worked pattern):

• mug heat: STEAMING(S01) → fading(S03) → COLD(S20) — B01/B12 bookend.
• executor bounce (wordless emotion thermometer): MAX(S02) → HIGH(S09) → DROP(S11) → ZERO/SILENT(S12–S15, arc low point) → tempered-return(S16) → smallest-warm(S21). (Storyboard will add the uniqueness invariant "S02 是全片唯一 MAX"; no post-fall peak.)
• Tok|yo broken-JSON evidence: born/first-plant(B06-S09) → smoking-gun(B08) → clean footnote(S17) → faint constellation star(S22).
• DDL countdown spine: 24:00:00 → ~19:00 → 00:42 — strictly monotonically non-increasing across the whole film (storyboard enforces; never rewinds).
• REJECT(S11) ↔ ACCEPT(S16): deliberate mirror stamps so the centerpiece audit reads as the hinge between them.

8. Write the 6-column table + sub-plan + 铁律 + motif arcs to story/OUTLINE_DRAFT.md

Add a top-of-file Logline + Tagline + 双重身份 block (mirroring the intent), an empty ## ✅ 已定决策 block, and an ## ⚠️ 待你确认 block listing every open design question (e.g. centerpiece 5-page split OK? new mid-act wiki page OK? 侧栏铁律 OK?).

9. READINESS gate — PRE-user, cross-model, blind (NOT the final gate)

This is the author-controllable gate, run before the user has decided anything. By construction the artifact from step 8 has an empty 已定决策 + a non-empty ⚠️ 待确认 block and no user sign-off — so the FINAL gate's user_decision_record == 5 floor and its "open questions unresolved but advancing" veto are not yet satisfiable. Applying the full conjunctive APPROVE rule here would deadlock a fresh agent (stall, or fabricate a user approval). So the readiness pass scores only the dims the author controls and explicitly EXCLUDES user_decision_record + the unresolved-questions veto (see §EXACT gate → READINESS).

Run it as a two-step gate invocation (D4 — never call the gate cold):

1. Fan out the GATE REVIEWERS (Codex at xhigh, no model pin ‖ Gemini auto-gemini-3) on the files only (outline_spec.json + intent_spec.json + the lens files, inside the advisory fence — no orchestrator prose). Persist EACH as a review node: node_id review:<slug> (e.g. review:outline_codex_r1), node_type review, payload required {target_node_id: <outline_id>, reviewer: "codex"|"gemini", gate_kind: "outline", review_scores:{skeleton_fidelity:…, delta_accounting:…, coverage:…, page_rhythm_readability:…, story_cost_binding:…, motif_contract_completeness:…, safety_ip:…}} — and write a reviews edge {src: review:<slug>, dst: <outline_id>, type: "reviews"} (the gate walks reviews edges in; reviewed_by is the wrong direction and the fuser won't find it).
2. THEN invoke comic-cross-layer-gate <outline_id> --gate outline to fuse the score-nodes + adjudicate. (This is the OUTLINE_DRAFT_VALID stage: on a fresh outline identity_lock_feasibility / scene_lock_feasibility are unscorable — no assets exist — so the reviewers leave them null and the gate SKIPs them, never 0-substitutes; the effective draft floor is coverage ≥ 4 AND safety_ip ≥ 4. The readiness reviewers likewise leave user_decision_record unscored. What IS checked here: every referenced asset_id is DECLARED with a complete, generatable request — locked is NOT required until OUTLINE_FINAL_LOCK, after the asset layer.) On a FAIL verdict, fold the blockers and loop back to step 2 (bounded by MAX_OUTLINE_REVISIONS); on a clean readiness verdict, proceed to step 10.

Then schema-validate the (still-under_review) outline_spec node payload (cli/validate_wiki.py mirrors node_schema.json); on a schema error, run the MAX_DRAFT_ATTEMPTS repair loop with codex-reply quoting the errors verbatim. Also run the 2 structural checks JSON-Schema can't express: (i) coverage — every intent.dual_identity "must-land" item and every skeleton beat maps to ≥1 table row; (ii) MIN_CAST_PER_BEAT — every beat names ≥1 world + its cast. Do not flip to locked yet — that needs the user sign-off (step 10).

10. USER APPROVAL = HARD GATE → FINAL gate → then lock

Present the readiness-clean outline to the user. Nothing proceeds until they sign off. On approval:

• record inline ✅ APPROVED by user <date> (with their words, e.g. ("都可以")),
• fill the ## ✅ 已定决策（用户 <date>） block — every resolved open question becomes a recorded decision node (our run: B06-S09 → big panel; Tok|yo pre-plant → very small, narration does NOT spell it out; B13 constellation → pure glowing star-points, NO labels),
• empty the ## ⚠️ 待你确认 block (every open question is now in 已定决策).

Now — and only now — run the FINAL gate (D4 two-step again): re-fan the GATE REVIEWERS on the now-complete artifact, persist fresh review:<slug> nodes (this round CAN score user_decision_record, since the sign-off + 已定决策 block + emptied 待确认 block exist) with reviews edges, then call comic-cross-layer-gate <outline_id> --gate outline. The FINAL gate applies the full conjunctive APPROVE rule (§EXACT gate → FINAL) including user_decision_record == 5, now satisfiable. On the gate's approve:

• the gate itself mints the decision node (node_id decision:outline_<slug>, payload required {target_node_id: <outline_id>, verdict: "approve", gate_kind: "outline"}) + the decides edge and flips the outline_spec node status: locked — that FLIP is the gate's job, not this skill's. (Never write status: locked by hand without the gate's approve verdict node and the inline user sign-off.)
• declare the file "SOURCE OF TRUTH for the storyboard layer."

Then hand off to comic-storyboard-creator for its PROVISIONAL structural pass (it inherits the locked beats

• the motif arcs as its continuity ledger). Asset generation/review, OUTLINE_FINAL_LOCK, and the storyboard's FINAL asset-resolution validation follow — comic-author steps 4–6b.

EXACT gate — this skill's PRE-gate rubric, fused by comic-cross-layer-gate --gate outline

Authority note (D3) — the N1 TWO-STAGE contract: the canonical APPROVE predicate + the status FLIP for the outline gate are owned by comic-cross-layer-gate --gate outline, and under the N1 DAG that gate runs in two stages:

• OUTLINE_DRAFT_VALID (this skill's readiness + final passes) — validates narrative + continuity + safety only. It does NOT require any referenced asset to be locked (on a fresh project assets don't exist yet); it requires every referenced asset_id to be DECLARED with a complete, generatable request. Because no locked assets exist, the gate-floor dims identity_lock_feasibility / scene_lock_feasibility are unscorable at draft time: the reviewers leave them null, the fuser SKIPs them (never 0-substitutes), and the effective draft floor reduces to coverage ≥ 4 AND safety_ip ≥ 4 — this is the explicit resolution of the dim-vocabulary gap (the reviewers here never score those two dims; nobody does until assets exist).
• OUTLINE_FINAL_LOCK (orchestrator-owned — comic-author step 6a, AFTER the asset layer locks) — a cheap re-check that the now-locked assets still match the approved outline; identity_lock_feasibility / scene_lock_feasibility ARE scored here, against real locked assets. The hard locked-asset barrier itself stays downstream, before blueprint authoring (comic-author steps 6b–7). This replaces the deadlocked single-stage contract (an outline gate demanding locked assets that depend on a storyboard that depends on a locked outline). The dims + verdict rules below are THIS skill's pre-gate routing (step 9 step-1 fan-out): the rubric the GATE REVIEWERS score into their review:<slug> nodes, and the local stop-rule this skill uses to loop/abandon before deferring to the fuser. They are not a competing gate — the cross-layer-gate fuses these score-nodes and makes the final call.

Each GATE REVIEWER scores these dims 0–5 seeing ONLY outline_spec.json + intent_spec.json (the skeleton) + the lens files — no orchestrator prose:

• skeleton_fidelity — beats / shots / beat boundaries from the locked skeleton are preserved or every change is an accounted delta (no silent re-derivation).
• delta_accounting — every candidate has a deltas vs the skeleton section; the synthesized outline's added/merged pages are all listed and justified.
• coverage — every intent.dual_identity must-land item + every skeleton beat maps to ≥1 table row with the right cast in must_show (the comic analog of aris_movie's coverage dim).
• page_rhythm_readability — layout tokens give a real scroll-read rhythm; the centerpiece is single-read paced; non-ML reader can follow the headline arc (readability — Gemini co-scores).
• story_cost_binding — every ARIS 特性 cell is phrased as a story cost that changes a character state, never a bare feature name.
• motif_contract_completeness — all motif arcs are locked with exact per-shot values (not "a recurring mug"); REJECT↔ACCEPT mirror + monotonic DDL declared.
• safety_ip — no celebrity likeness / copyrighted character / trademarked logo / off-policy content; anti-IP must_avoid carried into the style bible (HIGHER = better).
• user_decision_record — the ✅ APPROVED stamp + 已定决策 block (resolved questions as decision nodes) + an EMPTY ⚠️ 待确认 block are all present and consistent. Scored in the FINAL round ONLY — at step 9 it is not yet satisfiable, so the READINESS reviewers leave it null (the fuser SKIPs a null dim, it does not 0-substitute).