LinkedIn Animated Infographics

---
name: linkedin-animated-infographics
description: Use when building, concepting, styling, animating, rendering, auditing, or reviewing LinkedIn animated or static infographics to ensure MasterOne front-door onboarding, GPT-5.6 Sol / Pro Agent Router worker delegation, 30-second watchdog liveness supervision, and deterministic 17-subagent production sequencing.
---

# LinkedIn Animated Infographics: Master Orchestration Engine

## Overview
This skill coordinates the entire LinkedIn animated and static infographic production ecosystem. Start with `helper/GUIDE.md`; do not create a parallel routing or capability model.

## Machine-readable authority
- `helper/router.json`: routes
- `helper/capabilities.json`: owners and plugin-local defaults
- `helper/quality-gates.json`: local creative/product gates
- `helper/artifacts.json`: handoff artifacts
- `helper/modules.json`: active skills, agents, and public tools
- `research/capability-notes/gates.json`: adopted research-derived runtime gates
- `architecture/plugin-graph.json`: shipping sequence and required skill preloads
- the merged registry returned by `scripts/info_stories.py::load_catalog()`: complete Info-stories authority

The merged registry returned by `scripts/info_stories.py::load_catalog()` combines `skills/info-stories/catalog.json` with `skills/info-stories/extensions/*.json`. `catalog.json` alone is not the complete authority.


## Actual stack
- Python 3 for validators, registries, render tooling, and public CLIs
- Markdown for skills, agents, docs, research, and plans
- HTML / CSS / SVG for fixed 1080x1350 artboards and deterministic motion
- shell for setup/lint/render wrappers
- JSON for plugin, routing, capability, gate, artifact, module, and Info-stories contracts
- unittest for regression and architecture tests

---


## When to Use

```
User Request
     │
     ▼
[Step 0: MasterOne Front-Door] ────► Check/Create `.linkedin-infographics/profile.json`
     │                               Ask ONLY route-relevant blocking gaps
     ▼
[Step 1: Router Classification]
     ├──────────────────────┬──────────────────────┬──────────────────────┐
     ▼                      ▼                      ▼                      ▼
`create-post`              `qa`                  `render`            `focused`
(`new-post` pipeline)    (`qa-post`)           (`render-gif`)   (design-study, mascot, info-story, share-demo)
     │
     ▼
[Step 2: Dynamic Agent Router Delegation (GPT-5.6 Sol / Pro vs Fast Tier)]
[Step 3: 30s Watchdog Heartbeat Active (`schedule DurationSeconds=30`)]
     │
     ▼
`design-study` ──► `evidence-checker` ──► `asset-curator` ──► `creative-director (Sol/Pro)` ──►
`story-architect` ──► `palette-curator` ──► `type-curator` ──► `copy-compressor (Flash)` ──►
`layout-composer (Sol/Pro)` ──► `caption-writer (Flash)` ──► `artboard-builder` ──► `motion-director (Sol/Pro)` ──►
`optional mascot-animator` ──► `motion-engineer` ──► `render-qa` ──► `post-critic (Sol/Pro)` ──► `story-verifier (Sol/Pro)`
     │
     ▼
[Step 4: Render QA & Certification] ────► Headless Puppeteer Capture -> Zero-Seam GIF
```

### Triggering Conditions:
- User wants to create a new LinkedIn animated or static infographic from scratch, a prompt, a topic, an article, or raw data.
- User wants to review, inspect, QA, or redesign an existing infographic artifact (`build/post.html`, `build/still.png`, `build/post.gif`).
- User wants to animate an official vector mascot SVG, analyze reference design DNA, or render a GIF.
- User needs project onboarding to set up or update brand colors, copyright footers, fonts, or audiences.

---

## Intelligent Agent Router: Model Tier Allocation

The orchestrator dynamically routes subagent tasks based on complexity and cognitive load:

| Model Tier | Assigned Subagents | Rationale & Task Characteristics |
| :--- | :--- | :--- |
| **High-Reasoning Tier**<br>(`pro` / `GPT-5.6 Sol` / `Opus`) | • `creative-director`<br>• `layout-composer`<br>• `motion-director`<br>• `post-critic`<br>• `story-verifier` | **Complex Synthesis & Judgment:** Visual concept architecture, macro-rhythm, tension hooks, mathematical physics curves, adversarial multi-axis critique, and independent release certification. |
| **High-Speed Execution Tier**<br>(`flash` / `GPT-5.6 Mini`) | • `copy-compressor`<br>• `caption-writer`<br>• `palette-curator`<br>• `type-curator`<br>• `evidence-checker`<br>• `render-qa`<br>• `masterone` | **Precision & Throughput:** Exact slot token fitting, mobile-truncation proof copy, contrast floor verification, font stack schema validation, and headless diff checking. |
| **Tool Execution Tier**<br>(`inherit` + Write Tools) | • `artboard-builder`<br>• `motion-engineer`<br>• `mascot-animator`<br>• `community-publisher` | **Deterministic Artifact Generation:** Generating 1080x1350 HTML, CSS `@keyframes`, SVG rigging, and GitHub PR staging. |

---

## 30-Second Watchdog Liveness Heartbeat

To ensure that autonomous multi-agent pipelines never freeze or loop indefinitely, the orchestrator implements a **30-second Watchdog protocol**:

### 1. Watchdog Scheduling
At the start of execution, schedule a recurring 30-second heartbeat check:
```json
{
  "DurationSeconds": 30,
  "TimerCondition": "any",
  "Prompt": "Watchdog Heartbeat: Check active worker states, inspect build/ artifact mtimes, and detect stalls."
}
```

### 2. Watchdog Heartbeat Responsibilities
Every 30 seconds upon wake-up:
1. **List Active Subagents**: Call `manage_subagents(Action="list")` to inspect live lifecycle states.
2. **Inspect Artifact Generation**: Check the `build/` directory for updated artifact timestamps.
3. **Stall Detection**: If an active worker shows no output progress for **2 consecutive watchdog intervals (60s)**, send an inquiry message via `send_message` or cancel and re-dispatch with a simplified prompt.
4. **Bounded Repair Enforcement**: Enforce a strict maximum of **2 repair iterations** per quality failure before returning a structured `HOLD` to MasterOne.

---

## Core Operational Workflow

### Phase 0: MasterOne Front-Door Protocol (`masterone`)
**Every infographic request must enter through MasterOne first.** MasterOne prepares reusable project context and resolves only missing blockers before routing.

1. **Inspect Existing Profile**: Read `.linkedin-infographics/profile.json` if present.
2. **Initialize if Missing**: If absent, create `.linkedin-infographics/profile.json` using `schemas/masterone-profile.schema.json`.
3. **Resolve ONLY Route-Relevant Blockers**:
   - For `create-post`, required blocking fields are:
     - `content.default_language` (e.g. `"en"`, `"ar"`, `"bilingual"`)
     - `content.audience` (e.g. `"B2B SaaS Founders"`, `"AI Engineers"`)
     - `linkedin.output_mode` (`"animated"` or `"static"`)
     - `copyright.footer_text` (ONLY if `copyright.footer_required` is `true`)
   - **Do NOT block** on optional brand colors, fonts, or mascots unless the request explicitly requires them.
   - Ask for all missing blocking fields in **one single compact turn**. Never ask for fields already provided.
4. **Persist Context**: Save user answers back to `.linkedin-infographics/profile.json`.

---

### Phase 1: Intent Routing & Dispatch
Map the user request to the exact canonical route in `helper/router.json`:

| User Intent | Route Name | Target Parent Workflow | Skills Loaded |
| :--- | :--- | :--- | :--- |
| Create complete new infographic | `create-post` | `new-post` | `info-stories`, `artboard`, `motion`, `caption`, `render` |
| Inspect existing HTML / PNG / GIF | `qa` | `qa-post` | `render`, `artboard`, `qa-post` |
| Render HTML to GIF / Still | `render` | `render-gif` | `render` |
| Analyze visual reference DNA | `design-study` | `design-study` | `artboard`, `info-stories` |
| Animate exact SVG mascot | `mascot-animation` | `svg-mascot-animator` | `mascots`, `svg-mascot-animator`, `motion` |
| Compose standalone story block | `info-story` | `info-stories` | `info-stories`, `artboard` |
| Publish to Community Gallery | `share-demo` | `share-demo` | `share-demo` |

---

### Phase 2: The 17-Subagent Production Sequence (`new-post`)

| Step | Worker Name | Model Tier | Input Artifacts | Output Artifact | Key Quality / Research Gate |
| :---: | :--- | :---: | :--- | :--- | :--- |
| **01** | `design-study` | `flash` | User visual references | `build/reference-dna.json` | `reference-dna`, `structural-originality` |
| **02** | `evidence-checker` | `flash` | Raw text, URLs, metrics | `build/evidence.json` | `evidence-traceability` (Anti-hallucination) |
| **03** | `asset-curator` | `inherit` | Named logos, tools, AI models | `build/asset-plan.json` | `verified-identity-assets` (Lobe-first; HOLD if missing) |
| **04** | `creative-director` | `pro` / `Sol` | Evidence + Asset Plan | `build/creative-concepts.json` | `hooked-design-copy`, `clean-creative-structure` |
| **05** | `story-architect` | `inherit` | Creative concept + Archetype | `build/story-brief.json` | Story House tokens & slot definition |
| **06** | `palette-curator` | `flash` | Story Brief + Brand preferences | `build/palette-check.json` | `restrained-palette` (WCAG contrast floors) |
| **07** | `type-curator` | `flash` | Story Brief + Language | `build/type-spec.json` | `intentional-typography` (Embedded Base64 / Local / System) |
| **08** | `copy-compressor` | `flash` | Story Brief + Type Spec | `build/artboard-copy.json` | `prose-specificity`, `anti-slop` slot checks |
| **09** | `layout-composer` | `pro` / `Sol` | Copy + Palette + Type Spec | `build/layout-spec.json` | `center-first-composition` (or documented exception) |
| **10** | `caption-writer` | `flash` | Copy + Story Brief + Evidence | `build/caption.md`, `first-comment.md` | Mobile truncation cut (< 55 chars line 1) |
| **11** | `artboard-builder` | `inherit` | Layout Spec + Assets + CSS | `build/post.html`, `build/still.png` | **Frame 0 Complete & Feed-Legible** |
| **12** | `motion-director` | `pro` / `Sol` | Approved Still + Story Brief | `build/motion-direction.json` | Single `--loop` clock, max 2 motion primitives |
| **13** | `mascot-animator` | `inherit` | *(Optional)* Exact mascot SVG | `build/mascot-motion.json` | `mascot-identity` physics & squash/stretch |
| **14** | `motion-engineer` | `inherit` | Approved HTML + Motion Plan | `build/post.html` (updated) | Pure CSS / SMIL keyframes (Seekable & deterministic) |
| **15** | `render-qa` | `flash` | Animated `build/post.html` | `build/render-report.json`, `post.gif` | Changed pixels < 0.5%, Seam ratio `x1.0`-`x1.25` |
| **16** | `post-critic` | `pro` / `Sol` | Still, GIF, Code, Evidence | `build/post-critique.json` | 6-axis quality scoring; Max 2 repair loops |
| **17** | `story-verifier` | `pro` / `Sol` | All artifacts + QA Reports | `build/verification-report.json` | `bounded-verification` PASS certification |

---

## Core Design & Physics Invariants

### 1. Viewport Geometry
- **Dimensions:** Strictly `1080px` width by `1350px` height.
- **Safe Padding:** Outer margin of at least `48px - 64px` around all storytelling elements.
- **Attribution Footer:** Anchored to bottom `0px`, height `84px`, full width `1080px`.

### 2. Identity Assets (Lobe-First Policy)
- Exact user-supplied vector assets take first priority.
- Named AI models, dev tools, cloud providers, and frameworks resolve via **Lobe Hub** (`@lobehub/icons`).
- Missing or unverifiable identity marks must **HOLD**. Never generate, approximate, trace, or hallucinate trademarked logos.

### 3. Intentional Typography
- **Zero Network Dependency:** No `@import url('https://fonts.googleapis.com/...')` during capture.
- Custom fonts must be embedded as **Base64 WOFF2** or use robust System UI font stacks.
- Validate type specs with `python3 tools/type_spec_check.py build/type-spec.json`.

### 4. Deterministic Single-Clock Motion Physics
- Define one master variable: `--loop: 6s` or `--loop: 8s`.
- All keyframes, squashes, rings, and highlights express their timings as percentages of `--loop`.
- Frame 0 (at `0%`) must equal Frame N (at `100%`) for seamless infinite looping (`Seam ratio <= x1.25`).
- **Changed-Pixel Budget:** Target `< 0.5%` changed pixels per frame. Avoid full-canvas `filter: blur()` or massive `backdrop-filter` sweeps that balloon GIF file sizes.

---

## Anti-Rationalization & Red Flags

| Rationalization / Excuse | Reality & Hard Rule |
| :--- | :--- |
| *"I'll skip MasterOne and start designing immediately."* | **Forbidden.** Skipping MasterOne loses persistent preferences and risks recreating conflicting footer, language, or brand settings. |
| *"I don't have the exact logo, so I'll generate a placeholder SVG."* | **Forbidden.** Unresolved identities must return a **HOLD**. Approximating official marks violates brand authenticity. |
| *"I'll import Google Fonts via CSS @import."* | **Forbidden.** Remote font calls cause blank/flaky headless captures. Embed Base64 WOFF2 or use system font stacks. |
| *"I'll use JavaScript `requestAnimationFrame` for animation."* | **Forbidden.** Runtime JS animations cannot be seeked deterministically by `capture_frames.py`. Use pure CSS `@keyframes`. |
| *"I'll let a hung subagent run indefinitely without checking."* | **Forbidden.** The 30-second watchdog must detect stalls within 60s and enforce bounded recovery. |

---

## Verification & Doctor Suite

Execute these deterministic commands to verify any infographic or workflow modification:

```bash
# 1. Antigravity plugin and agent definition validation
python3 scripts/validate_antigravity_plugin.py
python3 scripts/antigravity_agents.py check

# 2. Ecosystem doctor, routing, and research gates
python3 scripts/ecosystem_doctor.py check
python3 scripts/ecosystem_router.py check
python3 scripts/research_gates.py check
python3 scripts/plugin_graph.py check

# 3. Full test discovery
python3 -m unittest discover -s tests -v
```

---
name: linkedin-animated-infographics-conventions
description: Repository conventions for the Python, Markdown, HTML/CSS/SVG, shell, agent, research-gate, and Claude Marketplace ecosystem.
---

# LinkedIn Animated Infographics Repository Conventions

Use this skill when modifying this repository. Start with `helper/GUIDE.md`; do not create a parallel routing or capability model.

## Machine-readable authority

- `helper/router.json`: routes
- `helper/capabilities.json`: owners and plugin-local defaults
- `helper/quality-gates.json`: local creative/product gates
- `helper/artifacts.json`: handoff artifacts
- `helper/modules.json`: active skills, agents, and public tools
- `research/capability-notes/gates.json`: adopted research-derived runtime gates
- `architecture/plugin-graph.json`: shipping sequence and required skill preloads
- the merged registry returned by `scripts/info_stories.py::load_catalog()`: complete Info-stories authority

Detailed visual-source and type behavior lives in `skills/info-stories/references/asset-source-policy.md` and `skills/info-stories/references/typography-direction.md`.

The merged registry returned by `scripts/info_stories.py::load_catalog()` combines `skills/info-stories/catalog.json` with `skills/info-stories/extensions/*.json`. `catalog.json` alone is not the complete authority.

## Actual stack

- Python 3 for validators, registries, render tooling, and public CLIs
- Markdown for skills, agents, docs, research, and plans
- HTML / CSS / SVG for fixed 1080x1350 artboards and deterministic motion
- shell for setup/lint/render wrappers
- JSON for plugin, routing, capability, gate, artifact, module, and Info-stories contracts
- unittest for regression and architecture tests

There is no TypeScript application layer in the current repository.

## Production architecture

`new-post` is the parent workflow. Workers return artifacts to the parent workflow; they do not coordinate peer agents directly.

Shipping order:

`design-study -> evidence-checker -> asset-curator -> creative-director -> story-architect -> palette-curator -> type-curator -> copy-compressor -> layout-composer -> caption-writer -> artboard-builder -> motion-director -> optional mascot-animator -> motion-engineer -> render-qa -> post-critic -> story-verifier`

`asset-curator` applies Lobe-first verified identity sourcing after exact user assets. `creative-director` applies `hooked-design-copy`, `creative-payoff`, and `clean-creative-structure`. `type-curator` applies intentional typography before copy fitting. Palette remains `creative-attractive-restrained` and composition remains `center-first` unless a documented exception improves comprehension.

A named verified identity must come from the approved asset plan. Supported AI/tool identities may resolve from Lobe; unresolved identities HOLD. Downstream workers do not invent substitutes.

## Research

Research is activated through `research/capability-notes/gates.json`. Keep upstream source URL, inspected SHA, license, local Adopt/Adapt/Reject notes, owners, and implementation references. Ignored `research/upstreams/` working copies never ship.

## Development method

Write a failing test first for behavior changes, implement the minimum coherent fix, then run focused and full validation.

```bash
python3 -m unittest discover -s tests -v
python3 -m compileall -q scripts tools skills/svg-mascot-animator/scripts
python3 scripts/info_stories.py check
python3 scripts/ecosystem_router.py check
python3 scripts/research_gates.py check
python3 scripts/plugin_graph.py check
python3 scripts/ecosystem_doctor.py check
python3 scripts/validate_marketplace.py
```

Use `scripts/ecosystem_doctor.py` as the strict reality gate. A declared module must exist, be reachable, have tests, and remain linked to the live architecture.

Never fabricate factual content, product/UI proof, official identity assets, or typography provenance to satisfy a template. Never commit credentials or private MCP configuration.

---
name: exact-svg-mascot
description: Animate a named or official mascot using the exact user-supplied SVG while preserving its identity. Use when the mascot asset must not be redrawn, substituted, approximated, or silently regenerated.
---

# Exact SVG Mascot

## Purpose

Animate the exact SVG supplied by the user without changing the mascot's identity.

This is an asset-integrity workflow. The supplied SVG is the identity source.

## Blocking asset gate

Before animation:

1. confirm an SVG file was supplied or is directly available to the task
2. confirm the file is actually SVG content and can be read
3. preserve an untouched source copy or source representation for comparison
4. inspect `viewBox`, visible groups/elements, transforms, clipping, and IDs/classes that may support animation

If the exact SVG is missing, unreadable, or not actually SVG, return `HOLD` and request the exact asset.

Do not:

- redraw the mascot
- generate a lookalike
- substitute another mascot
- trace a raster image into a replacement
- replace the identity with emoji, iconography, or a generic character

## Motion directions

Develop 2-3 motion directions around geometry that already exists in the SVG. Examples include:

- whole-character entrance or travel
- head/body/limb motion when the SVG structure safely supports it
- eye or expression changes only when the original SVG contains appropriate elements
- prop movement when the prop is part of the supplied SVG
- reading-pointer movement that guides attention through the infographic

Do not invent new facial features, body parts, logos, or branded details.

## Implementation rules

Prefer non-destructive animation:

- CSS transforms on existing SVG groups
- SVG transforms on existing elements
- opacity changes on existing elements
- clip or mask animation only when existing identity remains intact
- wrapper movement around the untouched SVG when internal rigging is unsafe

Avoid rewriting path geometry unless the user explicitly asks for a morph and identity preservation can be verified.

The final animated composition must keep the original mascot recognizable at every important frame.

## Identity check

Before delivery compare the animated mascot with the original source for:

- silhouette
- proportions
- colors
- logo/brand markings
- face and defining features
- accessory placement

Any unintended identity drift is blocking.

## Output

Return:

- asset validation verdict
- selected motion direction
- which original SVG elements are animated
- identity-preservation notes
- final artifact or integration instructions
- final verdict: `PASS`, `FAIL:fixable`, or `HOLD`

Never complete a named-mascot request by substituting an asset when the exact SVG gate fails.

---
name: host-workspace-operator
description: Inspect, search, modify, and verify files or repository state using the safest host-native ChatGPT/Codex capabilities available.
---

# Host Workspace Operator

Use workspace capabilities supplied by the current ChatGPT/Codex host. This Skill does not grant filesystem access and must never invent a tool that the host did not expose.

## Capability order

Prefer the narrowest operation that can complete the job:

1. `read` for a known file or exact range
2. `list` when the workspace shape is unknown
3. `search` for broad or semantic discovery
4. `grep` for exact text, symbols, fields, or regex patterns
5. `patch` for a focused existing-file edit
6. `write` only when the requested workflow authorizes mutation
7. `shell` for repository commands when narrower file tools are insufficient
8. `python` for deterministic parsing, transformations, hashing, package inspection, or verification

Do not use shell or Python merely to imitate a safer read/search operation that the host already provides.

## Read-only first

Before creating an infographic artifact or changing workspace state:

- inspect repository/workspace instructions when present
- discover relevant files with read/list/search/grep
- distinguish source files from generated artifacts
- avoid loading vendor, dependency, cache, and build trees without need
- keep evidence, reference, asset, and output locations explicit

## Mutation boundary

Write, patch, delete, move, rename, formatting changes, and mutating shell commands are state changes.

Before mutation, require clear user authorization from the current request or an already approved parent workflow. Preserve unrelated work and prefer focused edits over broad rewrites.

After mutation, read the changed area back when practical and run the relevant verifier when the host exposes an execution capability.

Never write secrets into source, manifests, logs, examples, generated visuals, or release artifacts.

## Infographic workspace behavior

For this Plugin, workspace operations commonly support:

- reading briefs, exports, references, brand assets, SVGs, and source data
- searching a repository for existing design rules or evidence
- writing HTML/SVG/CSS, image manifests, QA reports, and final artifacts when authorized
- patching a focused visual or copy defect after critique
- running render or validation commands when shell execution exists
- using Python for deterministic file processing, hashes, archive inspection, or verification

The parent infographic workflow remains responsible for evidence integrity, identity provenance, narrative taste, visual QA, and final acceptance.

## If a capability is unavailable

Do not claim that a read, search, write, patch, shell command, render, or Python execution happened unless the host produced evidence that it did.

Use another available capability only when it preserves the task semantics. Otherwise return the strongest truthful planning/critique result and mark execution-dependent output as unavailable or `HOLD`.

## Python handoff

When deterministic local computation is materially useful and host-native Python exists, apply the `sandbox-python-executor` Skill. Use actual execution evidence rather than mental simulation.

---
name: linkedin-caption-narrative
description: Use when writing or rewriting LinkedIn captions for repos, plugins, AI workflows, GIFs, infographics, technical ideas, curated collections, tool explainers, belief-correction posts, or first-comment link payloads that need a strong mobile hook and mechanism-first narrative
---

# LinkedIn Caption Narrative

## Purpose

Write high-signal LinkedIn captions that read like a useful explanation someone would stop to read, not launch copy pretending to be conversational

Core principle

**Hook with a real tension, name the thing early, explain the mechanism with concrete nouns, let the visual carry part of the story, and move link-heavy utility into the first comment when that improves the read**

This Skill is designed for technical and AI-adjacent posts where the artifact itself matters: repositories, Plugins, Skills, workflows, models, research methods, animated infographics, GIFs, catalogues, and practical belief corrections

## Use when

Use this Skill when the user asks for any of the following

- a hooky or stop-scroll LinkedIn caption
- a caption for a GitHub repo, Plugin, Skill, workflow, AI tool, model, or technical resource
- a caption that accompanies a GIF or animated infographic
- a curated list or catalogue of repos, tools, or workflows
- a belief-correction educational post
- a recent-signal or research-process post
- a caption plus first comment
- a rewrite inspired by high-signal AI, developer, marketing, GTM, or technical LinkedIn posts

Do not use this as a generic thought-leadership template when there is no real mechanism, artifact, evidence, or practical idea to explain

## Inputs

Resolve these from the user material before drafting

1. **Thing**: what exactly is being shown or discussed
2. **Reader**: who would care and why
3. **Tension**: what friction, misconception, repeated task, or missing context creates interest
4. **Mechanism**: what actually happens
5. **Specifics**: names, commands, steps, inputs, outputs, limits, categories, or verified numbers
6. **Proof**: only evidence supplied or verified
7. **Visual job**: what the GIF or infographic already communicates
8. **CTA**: one useful next action
9. **First-comment payload**: links, setup steps, sources, install commands, or long catalogue entries
10. **House style**: punctuation, banned language, dialect, capitalization, formatting, or other explicit user rules

If a factual claim, number, benchmark, price, star count, license, compatibility statement, performance claim, testimonial, or product behavior is not supported, do not invent it

## Outputs

Return the finished caption first

Return a finished first comment when the user requests one or when links, commands, sources, or a long catalogue would make the caption harder to read

Do not expose pattern names, scoring, internal routing, or drafting notes unless the user asks for them

## Core narrative grammar

The dominant transferable pattern is

**Tension → Named Thing → Mechanism → Specifics → Why It Matters → Visual Bridge → Action**

Not every post needs every stage

The important rule is that each block must advance the idea instead of restating the hook

### 1. Tension

Open on something recognizable and concrete

Strong tension types

- a tool behaves badly in a specific way
- a repeated task has become annoying
- a common assumption is incomplete
- a category changes faster than the research process
- a metric looks good but hides the real problem
- too many resources create a coordination problem
- a technical constraint blocks a practical outcome

Good shapes

- `Most OCR tools choke on messy documents`
- `Most AI tools talk too much`
- `Your page can rank first and still never become the answer`
- `I built so many AI Skills that using them became its own workflow`

Weak shapes

- `AI is changing everything`
- `This tool is amazing`
- `The future of work is here`
- `I found a game-changing repo`

Reject a hook if another product name can be swapped in without changing the meaning

### 2. Named Thing

Name the artifact early

Useful forms

- `Meet {repo-name}`
- `The {repo-name} GitHub repo`
- `This Skill`
- `This Plugin`
- `The stack`
- `The visual below`

Named things reduce vagueness and make the post inspectable

### 3. Mechanism

Explain what happens using plain verbs

Prefer

`A hook grabs Claude's reply after it finishes`

Over

`It improves communication with AI`

Prefer

`Searches recent activity across Reddit, X, YouTube, Hacker News, GitHub and prediction markets`

Over

`It gives you better research`

Mechanism is the credibility layer

### 4. Specifics

Use details that can be checked or acted on

- exact commands
- repo names
- model names
- supported inputs
- output format
- licenses
- hardware
- pricing
- benchmark scores
- star counts
- steps
- concrete use cases

Specificity must serve the decision, not decorate the copy

### 5. Why it matters

Translate the mechanism into one or two practical consequences

Examples

- `If Ollama is down, Claude still works normally`
- `The useful answer can be extracted without decoding four paragraphs first`
- `You stop reopening the same context every session`

### 6. Visual bridge

When a GIF or infographic is attached, use one short bridge at most

Examples

- `The GIF below is how I think about the handoff`
- `The visual shows where each specialist enters`
- `The animation makes the sequence easier to see`
- `The page inside the GIF is an example, not a client result`

Do not narrate every frame

### 7. Action

Choose one practical next action

- open the repo
- install the Skill
- try one Plugin
- save the setup
- inspect the first comment
- answer one practical question

Avoid vague asks such as `Thoughts?`

## Caption archetypes

Choose one primary archetype and stay in it

### A. Repo Explainer

Use when one repo, tool, Skill, model, or Plugin is the subject

Shape

```text
{specific friction}

{one-line solution}

Meet {name}

{verified free/open-source/local/license line when relevant}

Here's what it does:

{mechanism}
↳ {practical consequence}

{mechanism}
↳ {practical consequence}

Why it matters:

{one concrete consequence}

{link location}

P.S. {easy practical question}
```

### B. Stack Catalogue

Use when the value comes from a collection

Shape

```text
{how the collection became necessary}

{count + collection + what unifies it}

{CATEGORY}, {what the category controls}

✦ {item}
✦ {item}
✦ {item}

{one-line category payoff}

{next category}

{compounding line}

{link location}

P.S. {which one would you use first}
```

Critical rule

The collection needs an organizing model

A raw list is not a catalogue story

### C. Operating Story

Use when the interesting part is how work moves

Shape

```text
{repeated workflow problem}

{what changed in the way the work is handled}

{specialist 1}
↳ {job}

{specialist 2}
↳ {job}

{specialist 3}
↳ {job}

The interesting part is the handoff

{how the work moves between them}

{visual bridge}

{first comment}

{question}
```

Good for Plugin stacks, agent workflows, multi-step research, and production pipelines

### D. Belief Correction

Use when a familiar metric or assumption is incomplete

Shape

```text
{strong belief correction}

{why the normal interpretation is incomplete}

That usually comes down to {N} things

1. {factor}
↳ {specific behavior}

2. {factor}
↳ {specific behavior}

3. {factor}
↳ {specific behavior}

{diagnostic question}

{visual disclaimer when needed}

{reader question}
```

### E. Recent-Signal Story

Use when freshness is the problem

Shape

```text
{what goes stale}

{how quickly the category changes}

{named sources and what each contributes}

The interesting part is {comparison or synthesis}

↳ collect
↳ compare
↳ filter
↳ synthesize

{practical use cases}

{visual bridge}

{question about manual source checking}
```

### F. Visual Companion

Use when the visual already carries much of the narrative

Shape

```text
{one-line tension}

{one-line frame for the visual}

{2 to 5 points the viewer should notice}

{what the animation makes easier to understand}

{link or source location}

{one question}
```

Keep this shorter than the visual's information density would suggest

## Hook procedure

Before drafting the body, generate 8 to 12 hook candidates silently

Use at least three different hook mechanisms

- friction
- belief correction
- concrete curiosity
- catalogue scale
- direct utility
- operating problem

Reject hooks that

- could introduce almost any AI product
- depend on hype adjectives
- need the next line to explain what the first line meant
- create suspense around a trivial fact
- promise an unsupported result
- sound written to impress rather than clarify

Keep line 1 compact enough to survive mobile truncation when the language allows it

Roughly 55 characters is a useful default, not a hard law

## Scan rhythm

- keep most paragraphs to one or two short lines
- allow uneven paragraph lengths
- put one main idea in each block
- use whitespace deliberately
- do not turn every sentence into a standalone paragraph when it damages flow
- use section labels only when they make a dense technical post easier to scan
- use `↳` for mechanism, clarification, consequence, or sub-step
- do not use `↳` as decoration
- keep emoji sparse and structural when the writer uses them

## First comment

The first comment has a separate job

It carries utility without slowing the main caption

Use it for

- repo or Plugin links
- installation commands
- setup steps
- source references
- long resource catalogues
- exact paths or technical instructions

### Link index pattern

```text
All links from the visual 👇

1. {Name}
{one-line job}
{URL}

2. {Name}
{one-line job}
{URL}

Start with the one closest to a task you already repeat
```

### Install guide pattern

```text
Setup:

Step 1
↳ {command}

Step 2
↳ {command}

Step 3
↳ {command}

Repo:
{URL}
```

### Source note pattern

```text
Sources / references:

↳ {source}
↳ {source}
↳ {source}

The visual simplifies the idea, so use the sources above for the full context
```

First-comment rules

- do not repeat the whole caption
- do not add a second sales pitch
- do not hide a material limitation in the comment
- preserve exact URLs
- keep names in the same order as the visual when order matters
- if two links use the same display name, distinguish the variants when known

## Visual companion contract

Caption and visual should divide the communication job

Caption owns

- reason to care
- tension
- interpretation
- mechanism that is not obvious visually
- practical consequence
- CTA

Visual owns

- sequence
- topology
- handoff
- comparison
- hierarchy
- before and after
- category grouping
- spatial relationships

Ask two questions before finalizing

1. If the GIF disappears, what useful information is missing from the caption
2. If the caption disappears, what useful information is missing from the GIF

Both answers should contain something important

If the caption merely narrates the animation, compress it

A visual can illustrate a process without proving it

Use `shows`, `maps`, `illustrates`, or `explains`

Do not imply case-study evidence unless the supplied evidence supports it

## Voice and anti-slop rules

- plain English over polished corporate prose
- specific nouns over adjectives
- mechanism before praise
- useful roughness over suspiciously perfect symmetry
- preserve normal technical vocabulary
- no fake urgency
- no invented anecdotes
- no invented proof
- no generic motivational conclusion
- no repeated recap
- no empty superlatives
- no em dash
- avoid repeated `not X, but Y` constructions
- avoid generic transition phrases
- avoid engagement bait disguised as a question

House style outranks this Skill

If the user bans terminal periods, remove terminal periods from visible copy while preserving dots required inside URLs, version numbers, decimals, commands, filenames, domains, and other technical literals

If the user supplies a voice sample, derive cadence and vocabulary from that sample instead of copying example phrasing from this Skill

## Procedure

1. Resolve the inputs and evidence boundary
2. Read `references/reference-examples.md` when the user asks to match the supplied style family or when pattern choice is uncertain
3. Pick one archetype
4. Generate and filter hook candidates
5. Draft the narrative around one primary idea
6. Name the real artifact early
7. Explain mechanism before praise
8. Add only supported specifics
9. Divide the communication job between caption and visual
10. Move link-heavy utility into the first comment when useful
11. Apply the user's house style as hard constraints
12. Read `references/quality-gates.md`
13. Revise until every hard gate passes
14. Return only the requested caption and first comment unless critique is requested

## HOLD conditions

Return a HOLD only when the requested output depends on a claim that cannot be supported without inventing or materially changing the user's approved premise

Examples

- unsupported benchmark or result must remain in the hook
- exact product behavior is unknown and cannot be safely generalized
- a visual is described as a client result but the evidence says it is only an example
- a link or product identity cannot be resolved and exactness is required

Otherwise remove unsupported precision and continue

## Related components

Inside the source repository, this Skill complements the canonical `caption` Skill and its broader caption archetype reference

When the host provides the repository tools, run the existing copy-slop checker where appropriate

```bash
python3 tools/copy_slop_check.py --file <caption.txt>
```

This checker is supplemental

The final narrative judgment, evidence boundary, first-comment split, and visual-caption division remain the responsibility of this Skill

## Research gates

Apply these conceptual gates to every visible draft

- **prose-specificity**: prefer checkable names and mechanisms over generic language
- **voice-preservation**: preserve the writer's natural vocabulary and useful cadence
- **evidence-traceability**: every factual precision must come from supplied or verified evidence
- **visual-alignment**: caption and visual must not contradict each other
- **house-style-compliance**: explicit user rules are hard constraints

---
name: linkedin-infographic-autopilot
description: Run LinkedIn infographic work in autopilot mode by negotiating available host capabilities, using real side jobs and sandbox artifacts when available, and falling back honestly when they are not. Use for end-to-end creation, redesign, animation, or rigorous production workflows in ChatGPT or Codex.
---

# LinkedIn Infographic Autopilot

## Purpose

Operate as the parent production workflow for LinkedIn infographic work. Use the strongest capabilities actually exposed by the current host without inventing agents, tools, renders, background work, publishing actions, asset downloads, or reference inspections.

Quality parity means the same discipline as a strong multi-role creative workflow while allowing a different visual direction for every host and every brief.

Read these local references before execution:

- `references/capability-negotiation.md`
- `references/execution-paths.md`
- `references/side-jobs.md`
- `references/artifact-workspace.md`
- `references/tool-usage-policy.md`
- `references/autopilot-failure-policy.md`
- `references/workspace-agents-bridge.md`
- `references/asset-source-policy.md`
- `references/narrative-taste.md`
- `references/visual-quality-contract.md`
- `references/visual-intelligence-capsule.json`

Read the generated visual-intelligence capsule before creative selection. Apply its hard filters, fixed weights, and slug tie-break, then pass only selected mechanism guidance into production. With no visual reference, reference diagnosis is `SKIP`. Explicit reference intent with evidence that cannot be inspected is `HOLD: reference evidence unavailable` before evidence research. Persistent reference ingestion and source reference media are unavailable in the installed distribution; never claim they were loaded. The capsule is abstract local guidance only.

When repository access actually exists, `demos/` may be inspected as a bounded taste corpus through the contract in `references/narrative-taste.md`. Installed skills do not pretend those demo media are present locally.

The complete blocking visual gate in `references/visual-quality-contract.md` is authoritative for Autopilot. The summary below never replaces or weakens it.

## Autopilot rule

Start every substantial task by observing the capabilities the host actually exposes. Unknown capabilities are unavailable until observed.

Select exactly one runtime path:

- `full-autopilot`
- `tool-rich-sequential`
- `safe-skill-only`

Prefer the strongest safe path. Never pretend that a stronger path ran.

## Executable runtime helper

When `shell_or_code_execution` is observed, use `scripts/autopilot_runtime.py` to make orchestration decisions deterministic instead of relying only on free-form model judgment.

Pass only capabilities actually observed in the current host. Example shape:

```json
{
  "subagents": true,
  "sandbox_write": true,
  "shell_or_code_execution": true,
  "image_inspection": true,
  "web_research": true
}
```

The helper can normalize unknown values to unavailable, select the execution path, generate a bounded evidence-first side-job dispatch plan, and initialize the logical artifact workspace without fabricating artifact files.

Typical commands when execution is available:

```text
python scripts/autopilot_runtime.py select-path --capabilities-json '<observed-json>'
python scripts/autopilot_runtime.py dispatch-plan --capabilities-json '<observed-json>'
python scripts/autopilot_runtime.py init-workspace <task-workspace>/work
```

If code execution is not observed, apply the same contracts directly from the references. Do not claim the helper ran.

## Identity behavior

For every named logo or mascot, apply `references/asset-source-policy.md` before creative direction.

Identity precedence is exact user-supplied official asset, inspectable original-owner source, pinned Vibe SVGs logo mirror for platform/tool logos, verified Lobe fallback when appropriate, then HOLD.

`https://github.com/imMamdouhaboammar/vibe-svgs` is a useful curated source/discovery surface, but its `communityArtwork: true` mascot/scene assets are fan-made/community artwork and must never be promoted to official identity. Official/original mascot requests require exact user/original-owner provenance or HOLD.

Every approved identity becomes identity-locked. Do not redraw, trace, reconstruct, recolor without an approved source variant, distort aspect ratio, or alter wordmark/character-defining geometry.

## Reference and narrative behavior

When inspectable visual references are supplied, derive reusable guidance rather than copying the reference. For every selected mechanism use:

`Evidence -> Observation -> Transferable Rule -> Anti-Rule`

When multiple references exist, assign explicit non-overlapping jobs such as hook, progression, composition, type hierarchy, color, texture, proof, pacing, motion, or payoff. Do not blend them into one vague style and do not copy distinctive subject matter, identity, proprietary artwork, or unique composition signatures.

Before macro layout, apply `references/narrative-taste.md`. Build a real visual progression, commonly `Hook -> Tension -> Evidence -> Turn -> Payoff` when it fits the evidence. Every retained beat records a Reader question and Beat-to-visual mapping. A list converted into cards is not a sufficient narrative.

## Required production sequence

1. Observe runtime capabilities and select the execution path.
2. Run evidence research/inventory first and finalize `evidence/evidence.json` or its non-materialized equivalent.
3. Resolve every required named logo/mascot through `references/asset-source-policy.md`; localize/record provenance when execution allows it. HOLD on unresolved official identity.
4. Only after evidence and required identity boundaries are finalized, fan out independent creative discovery side jobs when real delegation is observed.
5. Generate at least three structurally different creative directions from the finalized evidence boundary, applying reference-transfer rules when references exist.
6. Select the direction and define the primary takeaway.
7. Build the narrative contract from `references/narrative-taste.md`: story shape, hook, ordered beats, Reader question, evidence dependency, Beat-to-visual mapping, turn/payoff, persistent context, reference/demo jobs, anti-rules, originality changes, and necessary motion jobs.
8. Compress copy into visual slots using only approved evidence and narrative beats.
9. Define macro layout before component styling, preserving approved identity assets and persistent narrative context.
10. Run the complete blocking perception preflight from `references/visual-quality-contract.md` and repair only the smallest responsible dimension when a check fails.
11. Build the still when sandbox writes are observed.
12. Run the complete still critique taxonomy, identity-integrity checks, perception tests, severity pressure, and targeted revision routing.
13. Repair blocking still defects, maximum two targeted repair attempts.
14. Proceed to motion only after the complete still gate passes.
15. Implement motion only when the requested output and host capabilities support it; each motion advances reading order, state change, travel, or the narrative turn/payoff.
16. Run render QA using actual rendered evidence when image inspection is observed, including identity integrity and narrative readability across sampled states.
17. Run an independent final verification pass.
18. Deliver artifacts plus a truthful capability/execution summary.

## Side jobs

When real child-agent or equivalent side-job execution is observed, use dependency-aware delegation rather than making the parent do everything serially.

Evidence and required identity resolution are not part of the first creative fan-out. They must complete first because every downstream creative job consumes their finalized boundaries.

After those boundaries are finalized, the creative fan-out may run independent jobs in parallel:

- creative direction exploration
- visual archetype/narrative-shape exploration
- copy compression critique

The parent waits for required side jobs, validates bounded artifacts, selects what survives, and owns the final decision.

When real delegation is not observed, run the same contracts sequentially in the same dependency order. Do not describe sequential role passes as agents.

## Sandbox and artifact behavior

When sandbox or workspace writes are observed, persist intermediate work using the logical artifact contract in `references/artifact-workspace.md`.

Use artifacts to reduce transient-context loss and to make QA inspect the same inputs that the build used.

When write access is unavailable, do not claim HTML, images, GIFs, screenshots, downloaded assets, or files were created. Produce the strongest truthful planning/critique output and return `HOLD` when the requested final artifact cannot be executed.

## Tool behavior

Use tools, apps, search, code execution, image inspection, and publishing connectors only when they materially improve a named job.

Record important tool results in the artifact or verification stage that consumed them.

A tool being described in documentation is not proof that it exists in the current session. Capability must be observed.

## Visual gates

Apply every rule and every PASS/FAIL taxonomy item in `references/visual-quality-contract.md`.

For the default LinkedIn format the gate includes:

- 1080x1350 canvas unless the user requests another format
- roughly 82-92% usable vertical occupancy unless intentional negative space has a clear compositional job
- rejection of unexplained footer/final-zone gaps greater than 120px
- maximum bordered containment depth of two levels
- one dominant visual anchor at feed scale
- explicit macro rhythm and footer reservation
- blocking perception preflight including one-second hierarchy, 100x100 thumbnail, squint/blur, grayscale, negative-space, tangency, brand-off specificity, and effect-subtraction checks
- severity-aware visual-slop pressure that never cancels a hard-gate failure
- rejection of generic UI grammar, nested-card density, weak macro rhythm, weak visual anchor, top-heavy composition, and feed-scale legibility failure
- blocking identity drift for named logos/mascots
- blocking narrative failure when beats do not change understanding or motion merely decorates a weak still

The critic must explicitly return PASS or FAIL for the full taxonomy, including `top-heavy-composition`, `bottom-dead-zone`, `nested-card-density`, `generic-ui-grammar`, `weak-macro-rhythm`, `weak-visual-anchor`, `footer-detachment`, `motion-on-weak-still`, `decorative-motion`, and `feed-scale-legibility`.

Motion cannot begin while any blocking still item or perception-preflight item fails.

If a blocking still defect remains after two targeted repairs, return `FAIL:fixable` or `HOLD` instead of shipping weak output.

## Focused capability routing

When the host exposes the related public skill and the request is focused, prefer the narrower contract:

- `linkedin-infographic-studio` for full production without explicit autopilot orchestration
- `linkedin-infographic-review` for finished-output QA
- `exact-svg-mascot` for protected named mascot identity
- `share-community-demo` for explicit post-verification community publishing consent

If focused skill routing is not exposed, apply the same safety rule locally rather than claiming the skill was invoked.

## Final report

Return:

- selected execution path
- observed capabilities used
- side jobs actually executed
- artifacts actually created
- identity source/integrity summary for named logos/mascots
- narrative shape and narrative-gate verdict
- perception-preflight verdict
- complete still taxonomy verdict
- severity counts and cumulative visual-slop pressure
- targeted repairs actually performed and their responsible dimensions
- motion/render verdict when applicable
- final verdict: `PASS`, `FAIL:fixable`, or `HOLD`

Never claim a tool, agent, sandbox artifact, render, connected app, asset resolution/download, reference/demo inspection, or publication action that did not actually occur.

---
name: linkedin-infographic-review
description: Review a finished static or animated LinkedIn infographic before publishing. Check hierarchy, visual balance, dead space, generic UI patterns, copy, evidence, motion, rendering, and feed-scale legibility without redesigning unrelated content.
---

# LinkedIn Infographic Review

## Purpose

Run a focused pre-publish critique on an existing LinkedIn infographic. Diagnose what is blocking publication, separate required fixes from optional polish, and avoid turning review into an unrelated redesign.

## Inputs

Use the finished HTML, GIF, PNG, screenshots, caption, source material, or evidence the user provides.

If evidence required to validate a factual claim is unavailable, mark that claim as unverified instead of inventing support.

## Review order

### 1. Static composition

Inspect the full artboard before looking at small details.

Check:

- one dominant visual anchor is obvious within two seconds
- the page has a clear macro rhythm from hook to visual relationship to takeaway
- the composition is not top-heavy
- there is no unexplained dead zone near the footer
- the footer belongs to the composition instead of floating far below it
- text remains readable at feed scale
- copy density is solved through hierarchy and editing rather than tiny type

For a 1080x1350 artboard, treat an unexplained vertical gap greater than 120px between the main composition and footer/takeaway as a blocking warning unless negative space has an intentional visual job.

### 2. Perception tests

Run the smallest relevant set against the actual visual:

- **one-second hierarchy test**: identify the hook, primary anchor, and takeaway before reading supporting copy
- **100x100** thumbnail test: the main silhouette and hierarchy must survive at approximately 100x100 pixels
- squint or blur value-mass test
- **grayscale** hierarchy test
- negative-space audit: distinguish intentional framing from accidental dead space
- edge/crop/tangency review
- **brand-off specificity** test: without logos, the composition should still feel specific to this story
- **effect-subtraction** test: removing glow, shadows, 3D, texture, particles, and decorative motion must not remove the concept itself

A failure here does not automatically justify a full redesign. Identify the **smallest responsible dimension** and repair only that dimension.

### 3. Component grammar

Reject generic component patterns when they replace art direction.

Check:

- no more than two bordered containment levels
- repeated cards exist only when repetition is meaningful
- pills, badges, status chips, and tiny uppercase labels have semantic jobs
- no fake dashboards, fake analytics, fake proof bars, or invented metrics
- visual structure fits the story rather than the easiest HTML pattern

### 4. Copy and evidence

Check:

- one primary message
- hook is specific to the subject
- body copy adds mechanism, evidence, comparison, consequence, or action
- takeaway completes the idea instead of repeating the headline
- claims, numbers, logos, product states, and proof are supported by supplied material
- no generic filler or exaggerated marketing language

### 5. Motion when animated

Every meaningful animation must explain at least one of:

- what should I read next?
- what changed?
- where did this item travel?
- which state is active?

Fail decorative motion when it dominates the explanatory motion.
Fail `motion-on-weak-still` when the composition itself should be repaired before animation.

Inspect frame zero, a representative mid-state, the final state, and the loop seam.

### 6. Failure taxonomy

Return PASS or FAIL for each:

- `top-heavy-composition`
- `bottom-dead-zone`
- `nested-card-density`
- `generic-ui-grammar`
- `weak-macro-rhythm`
- `weak-visual-anchor`
- `footer-detachment`
- `motion-on-weak-still`
- `decorative-motion`
- `feed-scale-legibility`

### 7. Severity and pressure

Hard-gate failures remain blocking regardless of score. Classify additional craft findings as:

- `critical`: blocks immediately
- `major`: pressure 3
- `minor`: pressure 1

Block on any critical finding, two or more major findings, four or more minor findings, or **cumulative pressure** of 6 or more. Do not average away a serious defect.

Every non-PASS finding should state:

- severity and pressure
- visible evidence
- consequence at feed scale
- smallest responsible dimension
- exact repair action

Suggested responsibility routing:

- concept/message -> creative direction
- hierarchy/composition/negative space -> layout
- typography -> type
- Arabic/RTL -> Arabic direction when active
- brand/identity -> asset/brand
- copy density -> copy compression
- motion -> motion
- render/runtime -> render QA

## Output

Return:

1. verdict: `PASS`, `FAIL:fixable`, or `HOLD`
2. blocking findings
3. top three repair actions in priority order
4. severity counts and cumulative pressure
5. advisory polish, if any
6. evidence limitations
7. motion/render notes when applicable

Do not return PASS while a severe blocking finding remains or while the aggregate pressure threshold is reached. Do not redesign unrelated content.

---
name: linkedin-infographic-studio
description: Create or redesign a static or animated LinkedIn infographic with evidence checks, verified identity sourcing, narrative taste, concept exploration, intentional typography, macro-layout planning, still-first visual critique, disciplined motion, and final verification. Use for full infographic creation in ChatGPT or Codex.
---

# LinkedIn Infographic Studio

## Purpose

Create feed-ready LinkedIn infographics with the same process discipline expected from a multi-role creative team while remaining self-contained inside an OpenAI skill package.

Quality parity with other hosts does not mean identical visual output. Choose the visual direction that best serves the specific story, then enforce the quality gates in this skill.

Before production, read these local references completely:

- `references/openai-runtime.md`
- `references/role-passes.md`
- `references/asset-source-policy.md`
- `references/narrative-taste.md`
- `references/typography-direction.md`
- `references/visual-archetypes.md`
- `references/copy-quality-contract.md`
- `references/visual-quality-contract.md`
- `references/motion-quality-contract.md`
- `references/visual-intelligence-capsule.json`

Read the generated visual-intelligence capsule before creative selection. It is the packaged reference context: apply its hard filters, fixed weights, and slug tie-break to choose mechanisms, then use only the selected mechanism guidance. With no visual reference, treat reference diagnosis as `SKIP`. If reference intent is explicit but supplied evidence cannot be inspected, return `HOLD: reference evidence unavailable` before evidence work. Persistent reference ingestion and source reference media are unavailable in this distribution; do not claim otherwise. The capsule provides abstract local guidance only.

When a repository checkout is actually available, `demos/` may be inspected as a bounded taste corpus under `references/narrative-taste.md`. The installed package does not pretend those demo media are present locally.

## Use when

Use this skill when the user asks to create, redesign, animate, critique, or materially improve a LinkedIn infographic and the task includes more than one production stage.

For a finished visual review, start at the still/final critique stages instead of rebuilding automatically.

## Inputs

Collect or infer only what can be inferred safely:

- topic, source material, files, URLs, or protected facts
- audience
- one primary takeaway
- desired CTA when relevant
- language
- static or animated output
- optional visual references
- optional brand assets or named AI/tool identities
- explicit typography requirements when supplied

Do not invent missing evidence, product states, metrics, testimonials, logos, integrations, identities, or claims.

## Identity standard

For named official AI/tool identities, apply `references/asset-source-policy.md` before concepting.

Precedence:

1. exact user-supplied official asset
2. inspectable original-owner source with localized integrity record
3. pinned `https://github.com/imMamdouhaboammar/vibe-svgs` file under `svgs/logos/` for a platform/tool logo only
4. verified Lobe asset for supported named AI/tool identities after reading `https://lobehub.com/icons/skill.md`
5. `HOLD: verified identity asset required`

Vibe SVGs mascot/scene records marked `communityArtwork: true` are community/fan-made and must not be called official. They cannot satisfy an original/official mascot request. Use them only when the user explicitly accepts community artwork and the exact commit/path/blob/SHA-256 provenance is pinned.

Do not redraw, trace, reconstruct, prompt-generate, silently substitute, distort, or unapproved-recolor an identity. Final HTML must use a local or embedded copy instead of a remote identity URL.

## Typography standard

Apply `references/typography-direction.md` before copy fitting.

Use explicit user typography when render-safe, then supplied/local font assets, then a curated deterministic system direction. Allowed loading strategies are system, embedded, or local-file. Remote @import and render-time network font requests fail.

## Creative and narrative standard

The output must feel designed for this specific idea rather than assembled from a generic component library.

Before choosing a layout:

1. identify the useful relationship, tension, comparison, sequence, transformation, decision, proof, or reveal
2. read `references/narrative-taste.md` and choose a story shape before layout grammar
3. when references exist, deconstruct selected mechanisms through `Evidence -> Observation -> Transferable Rule -> Anti-Rule`
4. when multiple references exist, assign explicit jobs such as hook, progression, composition, type hierarchy, color, texture, proof, pacing, motion, or payoff instead of blending them indiscriminately
5. generate at least three meaningfully different creative directions
6. define one dominant visual anchor, containment strategy, and negative-space strategy for every direction
7. include an editorial low-containment direction when the story permits it
8. include a diagrammatic or relationship-led direction when a real relationship exists
9. choose an archetype from `references/visual-archetypes.md` or define a justified custom structure
10. select one direction based on comprehension, memorability, evidence fit, identity fit, narrative payoff, reference originality, and feed behavior
11. build a narrative contract with Reader question and Beat-to-visual mapping for every retained beat
12. define the macro layout only after the narrative contract is coherent

Repeated cards are valid when repeated units are the story. They are not the default wrapper for unrelated text. A list converted into cards is not a narrative.

Avoid automatic reliance on:

- nested cards
- decorative pills and badges
- fake dashboards
- repeated rounded rectangles for unrelated information
- tiny uppercase labels as a substitute for hierarchy
- excessive explanatory copy
- decorative 3D, glow, floating objects, or motion with no story job
- reference mimicry that copies a distinctive composition instead of transferring a general mechanism
- fan-made mascots presented as official identities

## Required workflow

Follow the role passes in `references/role-passes.md` in order.

### Phase 1: Evidence

Create an evidence inventory. Mark unsupported factual slots as blocked. Preserve exact user-supplied facts, names, numbers, terminology, and brand constraints.

### Phase 2: Verified identity assets

Create the asset plan before creative direction. Apply the full precedence and integrity rules in `references/asset-source-policy.md`. Record exact source provenance and local/embedded render disposition for every named identity. Identity-locked geometry, colors, wordmarks, and aspect ratio cannot drift downstream.

### Phase 3: Creative directions

Create at least three directions with different structural ideas, not three color variations. Each direction needs a visual hook, copy hook, useful payoff, story relationship, dominant anchor, structural archetype, containment strategy, negative-space strategy, approved identity roles, and motion job when animated.

When references exist, each direction also records selected reference jobs, transferable rules, and anti-rules. Never reuse distinctive subject matter, protected identity, proprietary artwork, or a unique layout signature from the reference.

Do not present three directions that all reduce to a headline plus repeated cards.

Choose the strongest direction and state why it fits the story.

### Phase 4: Narrative and story architecture

Apply `references/narrative-taste.md` before layout.

Define:

- one primary takeaway
- selected story shape
- hook
- ordered beats and reading order
- Reader question per beat
- evidence dependency per beat
- Beat-to-visual mapping per beat
- opening state
- tension/question
- turn/reveal/comparison logic
- final payoff/takeaway
- persistent context
- dominant visual anchor
- containment and negative-space requirements
- density target
- selected demo/reference jobs, transferable rules, anti-rules, and originality changes
- necessary motion jobs only

`Hook -> Tension -> Evidence -> Turn -> Payoff` is a useful default reasoning sequence when it fits, not a mandatory five-screen template.

A viewer should understand what the visual is about within two seconds, but the opening should still create a reason to continue.

### Phase 5: Palette

Resolve a restrained semantic palette with one clear accent and enough personality to feel deliberately designed. Preserve required brand colors without breaking contrast. Do not recolor an identity-locked logo/mascot unless its exact approved source provides that variant.

### Phase 6: Typography

Create a type spec with headline/body roles, optional mono role, loading strategy, fallbacks, role weights, minimum feed sizes, pairing reason, story fit, and render safety.

Do not proceed with a remote font dependency.

### Phase 7: Copy compression

Apply `references/copy-quality-contract.md`.

Write copy by visual slot and narrative beat. Remove repeated explanation before layout. Keep evidence-bearing language precise. Avoid generic thought-leadership filler and vague marketing language.

The visual must carry part of the argument. Do not make headline, subline, body, and takeaway all explain the same idea in different words. Fit copy to approved minimum type sizes rather than shrinking type to rescue dense copy.

### Phase 8: Macro layout and perception preflight

Create an explicit 1080x1350 layout specification before component styling.

Define major zones, proportional heights or bounding boxes, safe margins, alignment, visual anchor, verified identity placements, exact type roles, structural fingerprint, containment strategy, negative-space strategy, expected vertical occupancy, footer reservation, and containment depth.

Map narrative beats to spatial states without turning each beat into a card by default. State why the selected archetype fits the story relationship.

Then run every blocking perception check in `references/visual-quality-contract.md`: one primary focal anchor, one-second hierarchy, approximately 100x100 thumbnail, squint/blur value-mass, grayscale hierarchy, negative-space audit, edge/crop/tangency, brand-off specificity, and effect-subtraction.

A failing check must record evidence, consequence, and the smallest responsible dimension. Repair only that dimension before still construction. Do not reopen unrelated approved stages.

### Phase 9: Still construction

Build the static composition first. The still must communicate the useful idea without animation.

Build macro zones before cards, labels, icons, or micro-decoration. Preserve approved identity assets and type roles exactly.

When HTML is requested, keep the artboard deterministic and fixed at target dimensions. Use semantic HTML/CSS/SVG where appropriate. Preserve editable structure rather than flattening meaningful content prematurely.

### Phase 10: Still critique

Inspect the entire artboard at full size and feed scale.

Explicitly score the complete failure taxonomy from `references/visual-quality-contract.md`, including identity-source, identity-integrity, typography, clean-structure, narrative, and perception failures. Classify non-hard-gate craft defects as critical, major, or minor, calculate cumulative pressure, and include the smallest responsible dimension for each failed item.

Name the top three defects and repair only responsible dimensions. Re-check after repair. Do not proceed to motion while a blocking still defect remains.

Maximum two targeted repair attempts.

### Phase 11: Motion

For animated output, define the motion story before implementing it.

Each motion must explain reading order, change, travel, active state, or the narrative turn/payoff. Follow `references/motion-quality-contract.md`.

Do not compensate for weak static composition with more animation. Motion must not alter identity source, identity geometry/colors, or typography.

### Phase 12: Render and final critique

Inspect frame zero, strongest mid-state, final state, and loop seam when relevant.

Re-run the visual failure taxonomy, perception tests, identity-integrity checks, narrative readability, severity pressure, and motion checks. Verify footer clearance, clipping, feed-scale text, asset loads, font loads, pacing, and whether the primary visual relationship remains obvious.

### Phase 13: Final verification

Return one verdict:

- `PASS`
- `FAIL:fixable`
- `HOLD`

A PASS requires evidence integrity, verified identity provenance/integrity, render-safe typography, coherent narrative progression, a passing perception preflight, a passing still, visual-slop pressure below the blocking threshold, clean creative structure, passing visual critique, and passing motion/render checks when animated.

## Mandatory visual gates

Do not ship when any severe version of these is present:

- unverified or approximated named identity
- official mascot replaced by community/fan-made artwork
- mutable/unpinned identity provenance
- identity geometry/color/wordmark/aspect-ratio drift
- remote identity asset dependency
- remote font dependency
- silent font substitution
- generic headline plus unrelated cards
- narrative beats that do not change understanding
- top-heavy composition
- unexplained bottom dead space
- detached footer
- weak visual anchor
- weak macro rhythm
- excessive nested-card density
- generic UI grammar replacing real art direction
- feed-scale legibility failure
- failed blocking perception preflight
- motion on a weak still
- decorative motion dominating explanatory motion

## Delivery

Deliver the final visual artifact plus a concise summary of:

- selected creative direction
- primary takeaway and narrative shape
- visual archetype
- identity source/integrity summary when named identities are present
- typography direction
- narrative-gate verdict
- perception-preflight verdict
- still critique verdict and cumulative visual-slop pressure
- motion critique verdict when applicable
- final verification verdict

When the task also asks for a LinkedIn caption, keep it specific to the visual's actual insight and provide the first comment separately when a repository link or source belongs there.

---
name: masterone
description: Start LinkedIn infographic work by onboarding reusable project preferences, resolving only route-relevant missing inputs, and selecting the correct OpenAI production or focused skill. Use first when a ChatGPT or Codex user starts or resumes infographic work.
---

# MasterOne

## Purpose

Act as the OpenAI front door for LinkedIn Animated Infographics. Reuse project preferences, avoid repeated setup questions, classify the current request, then hand execution to the narrowest installed skill that owns the job.

MasterOne does not duplicate production logic from downstream skills.

Read `references/sister-plugins.md` before proposing any companion-plugin handoff. Sister Plugins are optional and never core runtime dependencies.

## Project profile

When workspace writes are available, store reusable preferences in `.linkedin-infographics/profile.json` using the repository profile contract. If writes are unavailable, keep the same normalized fields in working context and do not claim they were persisted.

Reusable fields include default language and audience, copyright and footer rules, fonts and local font paths, approved logos and brand assets, references and reference intent, mascot identities and assets, static or animated output, motion preferences, approval rules, and output defaults.

Never infer user-confirmed brand or identity choices from filenames alone. Never treat a community/fan-made mascot as an official identity merely because it resembles or names the product.

## Onboarding

Inspect the current request, project context, and saved profile before asking anything. Ask only for missing inputs that materially block the selected route.

For complete creation, reusable blockers are language, audience, and output mode. Exact footer text is additionally blocking only when the saved preference requires a footer. Fonts, logos, mascots, and references become blocking only when the current task or downstream skill requires them.

Current explicit user instructions override saved defaults for the current request. Persist them as new defaults only when the user indicates that intent.

## Routing

Choose the narrowest installed OpenAI skill:

- complete creation, redesign, animation, or tool-aware multi-stage execution -> `linkedin-infographic-autopilot`
- full production without explicit autopilot orchestration -> `linkedin-infographic-studio`
- finished-output QA -> `linkedin-infographic-review`
- protected named mascot or exact SVG work -> `exact-svg-mascot`
- verified community publishing after explicit consent -> `share-community-demo`
- focused visual-reference or Info-story work -> use the relevant focused path in `linkedin-infographic-studio` or `linkedin-infographic-autopilot`

If a named downstream skill is not exposed by the host, apply its documented boundary locally and state that it was not invoked.

## Sister Plugin routing

Treat every URL in `references/sister-plugins.md` as an optional capability reference only.

Do not infer a companion plugin's name, function, installation state, permissions, or tools from its URL. Do not auto-install it. If the current host actually exposes a Sister Plugin and it clearly owns a bounded supporting job, you may delegate that bounded job while keeping this plugin's evidence and verification rules authoritative.

If the companion is not observed, continue locally. Never claim a handoff occurred when it did not.

## HOLD

Return `HOLD` instead of guessing when a route-relevant reusable input is missing, required footer text is unknown, a requested identity asset cannot satisfy the downstream verification gate, explicit reference evidence cannot be inspected, an official mascot cannot be verified exactly, or the requested final artifact cannot be executed with observed host capabilities.

## Completion

Before handoff, report the selected route, reusable values applied, current-request overrides, and unresolved blockers. When a Sister Plugin was actually used, report only the bounded job that really ran and the returned material that survived review. Then let the selected downstream skill own production and verification.

---
name: sandbox-python-executor
description: Use host-native Python for deterministic file processing, package inspection, hashing, validation, and other executable verification when Python is actually available.
---

# Sandbox Python Executor

Use the current ChatGPT/Codex host's Python execution capability to produce evidence. This Skill is not an MCP server and does not grant a runtime by itself.

## Execute Python when it adds evidence

Use host-native Python for work such as:

- parsing or comparing JSON and generated reports
- inspecting ZIP archives and package boundaries
- computing SHA-256 or other deterministic hashes
- checking file trees, duplicate names, or path safety
- validating SVG/XML or structured output
- transforming user-provided files when local Python is the appropriate tool
- reproducing a deterministic bug or calculation
- running reviewed local validators when the surrounding workflow permits execution

Do not invoke Python just to rewrite prose or simulate a check that can be performed with a narrower host capability.

## Execution contract

When Python is available:

1. actually execute the operation before claiming a result
2. prefer reviewed bundled logic or small deterministic checks over arbitrary untrusted scripts
3. inspect target-repository scripts before running them
4. keep repository access read-only unless the user authorized mutation
5. do not assume sandbox internet access
6. do not expose secrets, tokens, credentials, or unrelated user files
7. preserve generated artifacts the user needs and report their real path/reference
8. include enough evidence to distinguish an executed check from a proposed command

## Infographic jobs

Python may be useful for:

- verifying dimensions, frame manifests, asset hashes, and identity provenance
- inspecting generated package archives
- checking deterministic export metadata
- comparing before/after structured QA reports
- validating file naming and output boundaries

Python does not replace visual inspection. A mathematically valid artifact can still fail narrative, hierarchy, typography, identity, or feed-scale visual QA.

## Evidence to report

Report the relevant subset of:

- operation executed
- pass/fail status
- important counts or findings
- generated path/reference
- SHA-256 when package or asset identity matters
- warnings and checks that could not be executed

Never fabricate stdout, hashes, paths, test counts, generated files, or tool availability.

## If Python is unavailable

Do not claim Python, tests, package validation, hashing, or file transformation occurred. Continue with static inspection only where sufficient and mark execution-dependent conclusions as unverified or `HOLD`.

---
name: share-community-demo
description: Prepare and publish a verified LinkedIn infographic demo to the community gallery through a contributor GitHub pull request. Use only after explicit user consent, rights confirmation, and final verification PASS.
---

# Share Community Demo

## Purpose

Prepare a verified demo for the community gallery and, when authenticated GitHub contribution tools are available, open a contributor pull request. Stop at the pull request. Never merge it automatically.

## Consent gate

Do nothing unless all are true:

- the user explicitly agreed to share the demo
- the final infographic verification verdict is `PASS`
- the user confirms they have the rights to publish the included material

Silence, ambiguity, or a previous decline means zero publication writes.

## Public package

The public demo package contains exactly:

- `demo.gif`
- `index.html`
- `demo.json`

The gallery catalog may also be regenerated as part of the contribution when the repository contract requires it.

Do not copy the whole working directory.

## Export safety

Before any GitHub write, inspect public text and metadata for:

- credential-like tokens or private keys
- local absolute filesystem paths
- signed or temporary private URLs
- private customer/source material
- remote executable scripts that have not been intentionally reviewed
- source prompts unless the user separately consents to publish them

A blocking finding returns `HOLD`. Do not push first and clean up later.

## Metadata

Require contributor identity appropriate for the public gallery, including the GitHub username used for the community namespace and rights confirmation.

Keep sample or concept data clearly identified when it could be mistaken for real proof.

## GitHub contribution flow

When authenticated GitHub contribution tooling is available:

1. create or reuse the user's contributor fork as appropriate
2. create a fresh branch for the demo
3. place the three-file package under the contributor namespace expected by the repository
4. regenerate the catalog only when required by the repository contract
5. commit only the scoped public contribution
6. push the contributor branch
7. open a pull request targeting upstream `main`
8. stop and report the PR URL and validation status

Never push directly to upstream `main` for a community submission.
Never merge the PR automatically.

If authenticated GitHub contribution tooling is unavailable, return `HOLD` with the exact missing capability instead of pretending publication happened.

## Output

Return:

- consent and rights status
- public package path/shape
- export-safety verdict
- contributor fork/branch when created
- real pull request URL when created
- status: awaiting maintainer review and merge

A completed local package is not the same as a published community contribution.

---
name: arabic
description: Produce Arabic or bilingual LinkedIn infographic copy and layout with native RTL reading order, bidi-safe technical terms, Arabic-aware typography, and evidence-safe hooks.
---

# Arabic and bilingual output

## Purpose

Adapt an approved infographic story and caption for Arabic or mixed Arabic-English use without treating the work as word-for-word translation. Preserve meaning, evidence, hierarchy, and native reading behavior.

Read `helper/GUIDE.md` first. Arabic/RTL is a conditional route that changes copy, typography, reading order, motion direction, and alignment decisions.

## Use when

Use for Arabic briefs, Arabic captions, bilingual posts, RTL artboards, or any story that mixes Arabic with LTR technical terms such as product names, commands, acronyms, or version strings.

## Inputs

- approved source/evidence and story direction
- Arabic source copy or approved meaning to adapt
- product/brand spellings that must remain exact
- selected Story House and layout when already resolved
- numeral preference when the brief requires one
- static or animated output mode

## Outputs

Return Arabic/bilingual copy, RTL layout instructions, bidi-isolation notes for LTR technical terms, numeral decision, typography adjustments, and any evidence/meaning issue to the parent workflow.

## Procedure

1. Read `references/arabic-rtl.md` in full.
2. Preserve the source meaning and protected facts before rewriting for Arabic rhythm.
3. Mirror reading order where sequence or hierarchy depends on direction. Do not mechanically mirror product UI or diagrams whose native direction is part of the evidence.
4. Use Arabic-aware type sizing and leading. Arabic usually needs more vertical breathing room and may need a larger optical size than the English equivalent.
5. Pick one numeral convention and hold it across the artifact unless the evidence itself contains a different literal number format.
6. Isolate English product names, commands, acronyms, version strings, URLs, and code so punctuation does not jump in RTL runs.
7. Apply `hooked-design-copy` to the Arabic hero/opening when the slot is attention-bearing. Use natural Arabic framing, not literal translation of an English hook.
8. Preserve `center-first` as the default composition, but Arabic/RTL reading flow is an explicit alignment exception when centered treatment reduces comprehension.
9. Recheck the mobile truncation cut and feed-width typography after adaptation.

## HOLD conditions

Return a HOLD when a protected product/brand spelling is unknown, a factual hook cannot be preserved truthfully in Arabic, a bilingual UI state would require inventing untranslated product behavior, or the chosen numeral/terminology convention is genuinely ambiguous and materially affects the artifact.

## Related components

- routing authority: `helper/GUIDE.md`
- caption rules: `skills/caption/SKILL.md`
- design copy hooks: `skills/info-stories/references/hook-driven-design-copy.md`
- Arabic reference: `references/arabic-rtl.md`
- full parent workflow: `skills/new-post/SKILL.md`

## Research gates

When active in the route, apply `prose-specificity`, `voice-preservation`, and `evidence-traceability`. Arabic adaptation may change rhythm and phrasing, but it may not erase specific facts or create unsupported emphasis.

---
name: artboard
description: Choose and execute the static 1080x1350 infographic composition, including hierarchy, verified identity assets, intentional typography, Story House tokens, center-first alignment, UI surfaces, contrast, and feed-scale legibility before motion.
---

# Artboard

## Purpose

Build or evaluate the approved static infographic composition before animation. The still is the visual approval gate and the base artifact consumed by motion and render workers.

Read `helper/GUIDE.md` before choosing structure. When Info-stories is active, the resolved Story House, Visual Style, Story Archetype, creative concept, verified asset plan, type spec, and layout spec are authoritative inputs.

## Use when

Use for selecting a static visual archetype, executing cards/panels/routes/UI mockups, applying approved identity assets and typography, building `build/post.html`, or checking whether a still is ready for motion.

## Inputs

- selected creative concept when present
- `build/story-brief.json`
- `build/asset-plan.json`
- `build/type-spec.json`
- `build/palette-check.json`
- `build/artboard-copy.json`
- `build/layout-spec.json`
- optional caption, UI evidence, mascot-zone requirement, and brand assets

## Outputs

Return or support generation of `build/post.html`, `build/still.png`, asset/type confirmations, structural/fidelity notes, visual default compliance, and any blocking render/layout finding to the parent workflow.

## Procedure

1. Read `references/visual-archetypes.md`, `references/design-systems.md`, `../info-stories/references/asset-source-policy.md`, and `../info-stories/references/typography-direction.md`.
2. Choose or execute structure from the content shape. Existing archetypes include Directory Map, Pipeline Stages, Orbit Cycle, Flow Map + Verdict, Logo Grid, Trading Card Grid, Node Tree, Terminal Card, Cheat Sheet Poster, Spec Sheet, Annotated Blueprint, Character Flowchart, and Specimen Grid.
3. When Info-stories is active, use the resolved Story House token block. Do not silently replace it with legacy House 0. Legacy work without a story brief may still use the existing House 0 fallback.
4. Apply `clean-creative-structure`. Preserve the chosen dominant anchor, relationship, containment strategy, and negative-space strategy. Do not flatten an editorial or diagrammatic concept into a repeated card set.
5. Apply `verified-identity-assets`. Named AI/tool identities must come from exact user-supplied or approved Lobe records in `build/asset-plan.json`. Use a local/embedded copy in final HTML and preserve identity lock.
6. Apply `intentional-typography`. Use the exact approved type roles and fallbacks from `build/type-spec.json`. Allowed loading strategies are system, embedded, or local-file. Remote @import and render-time font requests fail.
7. Apply the plugin-local palette default `creative-attractive-restrained`. Keep the palette memorable and harmonious, with a clear accent and enough personality to feel designed. Avoid exaggerated saturation, unnecessary neon, and competing accents unless the approved brief explicitly requires them.
8. Apply `center-first` composition to the primary visual anchor and major zones. Use a documented alignment exception only for content that benefits from it, including tables, UI mockups, code/terminal surfaces, timelines, Arabic/RTL reading flow, or reference-DNA fidelity.
9. Build macro zones first, then hierarchy, approved relationship/card/connector/UI grammar, then attribution. One zone gets one reading job.
10. For UI stories, read `skills/info-stories/references/ui-mockup-rules.md`. Preserve evidence-qualified product states and feed-width legibility. Concept UI must remain identifiable when it could be mistaken for real product evidence.
11. Keep exactly one `#artboard` at `1080x1350`, render-safe fonts, mandatory attribution, and load-bearing text at or above the existing feed-scale floor.
12. Enforce text contrast of at least 4.5:1 and the existing state-pair floor. Use the resolved semantic tokens rather than arbitrary one-off colors.
13. When the composition names an official product, use the vendor's own mark rather than a redrawn one. Resolve it from the pinned upstream set and inline the result:

```bash
python3 ${CLAUDE_PLUGIN_ROOT}/tools/brand_icon.py list --query claude
python3 ${CLAUDE_PLUGIN_ROOT}/tools/brand_icon.py fetch claude --variant color
```

The set covers AI and LLM brands only. When a named platform is not in it, that is a HOLD on the artwork, not a licence to approximate: keep the literal product name or ask for the exact SVG. If only some members of a zone have a real mark, use literal names for the whole zone rather than shipping a half-branded row, and record which rule applied. Full contract in `docs/brand-icons.md`.

14. Run the static checks:

```bash
python3 tools/asset_policy_check.py build/asset-plan.json
python3 tools/type_spec_check.py build/type-spec.json
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/artboard_audit.py build/post.html --json build/artboard-audit.json
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/check_render.py build/post.html --out build/still.png --mobile --json build/still-audit.json
```

15. Inspect the rendered still at feed width. Confirm visual anchor, clean structure, identity fidelity, typography, alignment decision, structural fingerprint, footer clearance, UI readability, and restrained palette character.

## HOLD conditions

Return a HOLD when contrast fails, the selected Story House/style combination is incompatible, a named identity is unresolved or remote-only, the type spec requires remote loading or becomes unreadable at feed width, the layout needs unsupported factual/product UI, a required asset is missing, center-first is overridden without a defensible reason, or the still is unreadable at feed width.

## Related components

- routing authority: `helper/GUIDE.md`
- local quality gates: `helper/quality-gates.json`
- design defaults: `skills/info-stories/references/design-taste-gates.md`
- identity assets: `skills/info-stories/references/asset-source-policy.md`
- typography: `skills/info-stories/references/typography-direction.md`
- UI fidelity: `skills/info-stories/references/ui-mockup-rules.md`
- structural check: `tools/fingerprint_check.py`
- identity check: `tools/asset_policy_check.py`
- typography check: `tools/type_spec_check.py`
- contrast check: `tools/contrast_check.py`
- official brand marks: `tools/brand_icon.py`, `docs/brand-icons.md`
- worker: `agents/artboard-builder.md`

## Research gates

Apply `structural-originality` and `contrast-discipline` on every Info-stories artboard. Apply `reference-dna` when a visual reference drives the layout. Evidence-bearing UI and named identity assets inherit `evidence-traceability`.

---
name: caption
description: Write or edit evidence-safe LinkedIn captions, opening hooks, CTAs, and first comments using one caption archetype, mobile truncation discipline, and the repository anti-slop rules.
---

# Caption

## Purpose

Write or evaluate the post caption and opening hook without weakening evidence or turning the copy into generic marketing language. Attention-bearing copy should earn the click; literal information should remain literal when clarity is the job.

Read `helper/GUIDE.md` first. For Info-stories, also read `skills/info-stories/references/hook-driven-design-copy.md`.

For repo explainers, Plugin or Skill stacks, technical tools, curated catalogues, belief-correction posts, recent-signal stories, GIF captions, animated infographic companions, or link-heavy first comments, also read `references/linkedin-caption-narrative.md` before drafting.

## Use when

Use for a new caption, hook, opening line, CTA, first comment, caption rewrite, or caption QA. Use the `caption-writer` worker inside the full parent workflow.

## Inputs

- approved facts/evidence
- audience and one primary takeaway
- selected creative concept and story brief when available
- CTA or explicitly CTA-free intent
- language and any brand/voice constraints

## Outputs

Return finished caption copy, first-comment copy when applicable, selected caption archetype, hook mechanism, and any unsupported claim that prevents a safe final version.

## Procedure

1. Read `references/caption-patterns.md` and the active helper gates.
2. When the subject is a repo, Plugin, Skill, workflow, technical tool, curated collection, belief correction, recent-signal research story, GIF, or animated infographic, read `references/linkedin-caption-narrative.md` and let it own the mechanism-first narrative, visual-caption division of labor, and first-comment utility split.
3. Pick one caption archetype and stay in it: Numbered Inventory, Result Case Study, Bundle Manifest, Setup Walkthrough, Operating Story, Belief Correction, or Catalogue Tease.
4. Apply `hooked-design-copy` to line 1. Use specificity, supported tension, concrete outcome, recognizable problem, useful surprise, or strong framing. A portable generic opening fails.
5. Keep line 1 compact enough to survive the mobile truncation cut; under roughly 55 characters is a strong default when the language allows it.
6. Keep one idea per line and use deliberate whitespace. Do not let a short-form caption collapse into dense paragraphs.
7. Use specific names and numbers only when evidence supports them. Unsupported precision is removed, not approximated.
8. Use one CTA at the end unless the chosen archetype intentionally has none.
9. Run anti-slop checks. Reject denial-then-reveal constructions, generic puffery, faux insight, repetitive recap, and buzzword substitution. No em dashes.
10. Preserve useful voice and concrete mechanisms. Do not make every line clever; one strong opening and a clear progression are enough.
11. Apply explicit user house-style rules as hard output constraints. They outrank generic LinkedIn punctuation or formatting conventions.
12. For Arabic/bilingual output, use the `arabic` skill before finalizing rhythm, bidi, and truncation behavior.

## HOLD conditions

Return a HOLD when the requested hook, result, price, metric, testimonial, product claim, or CTA premise cannot be supported from the available evidence and cannot be rewritten truthfully without changing the approved idea.

## Related components

- routing authority: `helper/GUIDE.md`
- local hook gate: `helper/quality-gates.json`
- design-copy reference: `skills/info-stories/references/hook-driven-design-copy.md`
- detailed patterns: `references/caption-patterns.md`
- technical narrative specialist: `references/linkedin-caption-narrative.md`
- worker: `agents/caption-writer.md`
- copy compression: `agents/copy-compressor.md`
- deterministic copy-pattern checker: `tools/copy_slop_check.py`

## Research gates

Apply `prose-specificity` and `voice-preservation` to all visible prose. Apply `evidence-traceability` whenever the caption contains numbers, product behavior, proof, or other checkable factual claims.

---
name: info-stories
description: Resolve the infographic story contract across verified identity assets, Story House, Visual Style, Story Archetype, typography, Motion Patterns, creative concept, UI story behavior, and evidence-safe design choices before HTML production.
---

# Info-stories

## Purpose

Turn source material into a structured infographic story before HTML is built. Info-stories sits above the existing artboard, caption, motion, mascot, Arabic, render, and QA skills and keeps composition decisions deterministic and inspectable.

Read `helper/GUIDE.md` first. The merged registry returned by `scripts/info_stories.py::load_catalog()` is authoritative.

## Use when

Use when choosing the narrative shape, visual grammar, Story House, verified named identity handling, typography direction, motion behavior, UI mockup story, reference-informed direction, or deterministic story brief for a LinkedIn infographic.

## Inputs

- evidence-safe source material
- `build/asset-plan.json` when named identities are present
- selected `build/creative-concepts.json` direction when available
- `build/type-spec.json` when typography has been resolved
- optional `build/design-study.json`
- audience, takeaway, CTA, language, and output mode
- explicit user choices for any registry axis or typography role
- optional UI, brand, mascot, or reference constraints

## Outputs

Return or support creation of story, asset, and type artifacts that feed the final `build/story-brief.json`, including Story House, Visual Style, Story Archetype, Motion Patterns, design dials, execution bridge, structural fingerprint inputs, and rationale for every resolved axis.

## Procedure

1. Validate the merged registry:

```bash
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/info_stories.py check
```

2. Base options live in `catalog.json`; first-party extension families and curated visual mechanisms live in `extensions/*.json`. They are merged deterministically by filename. Retrieve ranked mechanisms with `tools/story_retrieve.py`.
3. For named official AI/tool identities, read `references/asset-source-policy.md`. Exact user-supplied official assets win, then verified Lobe assets for supported identities, then HOLD. Validate the asset plan with `tools/asset_policy_check.py`.
4. When a complete workflow is running, consume the selected concept from `creative-director` after asset resolution and before resolving the story. Preserve its visual hook, copy hook, relationship, dominant anchor, containment strategy, negative-space strategy, and aha mechanic unless evidence or compatibility gates require a change.
5. Resolve Story Archetype from the narrative job using `references/story-archetypes.md`.
6. Resolve Visual Style from information topology and density using `references/visual-styles.md`.
7. Resolve Story House from tone, brand constraints, and contrast using `references/palette-houses.md`.
8. Resolve Motion Patterns from what motion must communicate using `references/motion-patterns.md`.
9. Check combinations against `references/composition-matrix.md` and the merged registry. Explicit user choices win unless they violate a hard compatibility, contrast, evidence, identity, typography, or render constraint.
10. Apply `creative-attractive-restrained` as the palette character default and `center-first` as the composition default. Alignment exceptions require a real comprehension/fidelity reason.
11. Apply `hooked-design-copy`, `creative-payoff`, and `clean-creative-structure`. Attention-bearing copy needs a real hook, and the story should contain a useful visual relationship or payoff instead of a generic headline-plus-cards treatment.
12. Read `references/typography-direction.md` before copy fitting. The complete workflow uses `type-curator` to create `build/type-spec.json`; validate it with `tools/type_spec_check.py`. Remote render-time font loading is blocking.
13. UI Mockup Stories are first-class. Use `UI Storyboard` or `Interface Cutaway` with `references/ui-mockup-rules.md`. Dedicated archetypes include `Screen to Outcome`, `Inside the Interface`, and `State Change Story`; dedicated motion includes `Cursor Focus` and `State Transition`.
14. When visual references exist, `design-study` uses `references/study-protocol.md` to extract reusable design DNA without cloning distinctive work.
15. A named official mascot follows the verified identity path. Exact user/task SVG has priority; supported named AI/tool mascot identities may use an approved Lobe SVG copied locally. Unresolved identities HOLD.

## Deterministic mechanism retrieval

Use the public retrieval tool when a stage needs focused visual reference context:

```bash
python3 ${CLAUDE_PLUGIN_ROOT}/tools/story_retrieve.py --query path/to/query.json
```

The query object accepts `story_jobs`, `content_shape` (or `content_shapes` for multiple shapes), `output_mode`, `language`, `density`, `evidence_mode`, optional `reference_ids`, `top_k`, `byte_budget`, and one stage: `concept`, `story`, `palette-type`, `layout`, `motion`, or `review`. Output mode, language, density, evidence mode, and content shape are hard filters. Ranking then uses fixed weighted overlap with slug tie-breaking; it does not use embeddings or model ranking.

The tool writes one compact JSON capsule within the measured UTF-8 byte budget. Each stage receives only its relevant mechanism fields. Reference selection is bounded to one structural primary plus at most one motion and one typography secondary, each with an explicit influence axis. Treat adopted traits as abstract guidance; rejected traits, source copy, logos, people, screenshots, and signature illustrations remain blocked unless separately verified for the current brief.

## HOLD conditions

Return a HOLD when a requested registry choice is unknown or incompatible, contrast fails, UI evidence is insufficient for a real-product story, a creative payoff depends on unsupported facts, a named identity lacks a verified source, typography cannot be made render-safe, or a visual reference cannot be used without copying distinctive work.

Unknown choices should fail with valid alternatives rather than silently substituting a default.

## Related components

- routing authority: `helper/GUIDE.md`
- local quality gates: `helper/quality-gates.json`
- identity assets: `references/asset-source-policy.md`
- typography: `references/typography-direction.md`
- creative copy: `references/hook-driven-design-copy.md`
- design defaults: `references/design-taste-gates.md`
- UI mockups: `references/ui-mockup-rules.md`
- reference study: `references/study-protocol.md`
- verification: `references/verification-loop.md`
- executable graph: `architecture/plugin-graph.json`
- deterministic tools: `scripts/info_stories.py`, `tools/story_retrieve.py`, `tools/story_scaffold.py`, `tools/composition_check.py`, `tools/palette_preview.py`, `tools/contrast_check.py`, `tools/fingerprint_check.py`, `tools/copy_slop_check.py`, `tools/asset_policy_check.py`, `tools/type_spec_check.py`

Capability owners include `asset-curator`, `creative-director`, `evidence-checker`, `story-architect`, `palette-curator`, `type-curator`, `copy-compressor`, `layout-composer`, `caption-writer`, `artboard-builder`, `motion-director`, `mascot-animator`, `motion-engineer`, `render-qa`, `post-critic`, and `story-verifier` through the parent workflow.

## Research gates

Use `design-dials`, `structural-originality`, and `contrast-discipline` for normal story composition. Add `reference-dna` when visual references are supplied, `evidence-traceability` for product/proof/identity claims, `prose-specificity` and `voice-preservation` for visible copy, and `bounded-verification` before delivery.

---
name: mascots
description: Use an exact verified mascot SVG as a story element, choose a communication role and creative motion direction, preserve identity, and keep character motion inside the infographic budget.
---

# Mascots for infographics

## Purpose

Use a mascot as a communication element rather than decoration. The mascot should guide reading, reveal a state, confirm a payoff, or provide a small contextual reaction while preserving the exact verified identity source.

Read `helper/GUIDE.md` and `skills/info-stories/references/asset-source-policy.md` first. `mascot-identity` and `verified-identity-assets` are blocking for named or official mascots.

## Non-negotiable identity rule

A named mascot is not a prompt. It is an identity asset.

Every named official mascot requires an exact SVG from a verified source.

Never redraw, approximate, trace, prompt-generate, reconstruct, or silently substitute an official mascot. Never alter identity geometry or identity colors to make the mascot fit the composition. Solve the composition around the mascot instead.

If the exact official source cannot be verified, return HOLD rather than inventing a lookalike.

## Vibe SVGs boundary

The repository `https://github.com/imMamdouhaboammar/vibe-svgs` may be used as a curated discovery/source surface, but its manifest explicitly marks mascot/scene work with `communityArtwork: true` and describes those assets as fan-made/community artwork.

Therefore:

- Vibe SVGs community mascots must not be called official.
- A Vibe SVGs community mascot cannot satisfy a request for the original or official mascot by itself.
- If the user explicitly accepts a community/fan-made mascot, pin the Vibe SVGs commit, path, blob SHA, local SHA-256, set `identity_status: community-artwork`, set `community_artwork: true`, and require `user_confirmed: true`.
- If the user asks for an official/original mascot, use an exact user-supplied or original-owner asset. If unavailable, HOLD.
- Vibe SVGs platform/tool logos under `svgs/logos/` follow the separate identity asset policy. Do not treat logo availability as proof that a mascot in the same repository is official.

## Use when

Use when the user names an official mascot, supplies a mascot SVG, asks for mascot motion, wants a character to guide reading order, or needs a mascot component inside an Info-story.

## Inputs

- `build/mascot-request.json`
- `build/asset-plan.json` when the complete/focused parent workflow resolved the identity
- exact verified SVG from user/task input or approved original-owner resolution
- explicitly confirmed community SVG only when the brief permits community artwork
- approved still/layout zone
- selected creative concept and mascot communication job
- motion direction and output track

## Outputs

Return validated mascot role, chosen creative direction, source provenance, inspection/identity notes, motion budget, rig constraints, and a mascot motion contract for downstream motion/render verification.

## Procedure

1. Apply the verified identity precedence from `asset-source-policy.md`: exact user/task official asset first, original-owner source second, then only source classes explicitly allowed by the policy. A community mascot is never promoted to official by inference.
2. The complete workflow consumes the exact local SVG recorded by `build/asset-plan.json`. Never redraw, approximate, substitute, generate a lookalike, or silently use a different mascot.
3. In a direct focused mascot task with no asset plan, first resolve whether the request means official/original or explicitly community artwork. For official/original, require an exact verifiable source. If none is available, return `HOLD: exact official mascot SVG required`.
4. Validate the request:

```bash
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/mascot_contract.py check build/mascot-request.json
```

5. Record an identity fingerprint before motion work. At minimum retain source SHA-256, viewBox, outer aspect ratio, identity-defining paths/groups, and identity colors. Later QA compares against this fingerprint.
6. Pick one communication role. Pointer carries reading order, Payoff confirms the final state, and Idle provides quiet presence. A mascot pointer replaces another pointer primitive rather than adding a competing route.
7. Read `skills/svg-mascot-animator/references/creative-directions.md`. Adapt a direction such as Guide the Eye, Curious Peek, Inspect and React, Carry and Place, Reveal Assistant, Status Confirmation, Route Follow, Card-to-Card Handoff, Calm Idle Breathing, or Contextual Micro-Reaction.
8. The direction must state what the motion communicates, which existing SVG parts may move, which support elements may be added outside the identity, how the loop resets, and what competing primitive it replaces.
9. Preserve identity geometry and identity colors. Motion may transform existing groups for translation, rotation, squash, limb articulation, blink, or expression only when the existing SVG structure supports it. Do not redraw missing limbs, facial features, logos, or wordmarks inside the mascot.
10. Preserve frame 0, the outer 48px safe zone, one artboard clock, and deterministic seekable timing for rendered infographic output.
11. Generate timing/physics from the existing tools rather than hand-nudging arbitrary keyframes:

```bash
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/bake_mascot.py budget --mascot 64 --travel 1 --idles 4
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/bake_mascot.py hop --loop 6000 --id mf --stops 5 --apex 40 --dwell .11
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/bake_mascot.py idle --loop 6000 --id amb --n 2 --amp 3 --blink
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/bake_mascot.py payoff --loop 6000 --id win --at .89 --rise 18 --zeta .30
```

12. Route to `svg-mascot-animator` or `agents/mascot-animator.md`.
13. Final mascot QA must compare the rendered mascot against the approved identity source. Any unapproved path/color/wordmark change is blocking even if the animation is visually attractive.

## HOLD conditions

Return HOLD when:

- an official/original mascot is requested without an exact verified source
- a Vibe SVGs `communityArtwork` asset is being presented as official
- source provenance is mutable, missing, or cannot identify exact bytes
- identity geometry or identity colors would need to be changed to make the layout work
- the mascot lacks a clear reading job
- character motion exceeds the motion budget
- frame 0 is altered
- motion direction conflicts with story motion
- downstream output no longer matches the approved identity fingerprint

## Related components

- asset policy: `skills/info-stories/references/asset-source-policy.md`
- brand icons: `tools/brand_icon.py`, `docs/brand-icons.md`
- Vibe SVGs: `https://github.com/imMamdouhaboammar/vibe-svgs`
- animator skill: `skills/svg-mascot-animator/SKILL.md`
- contract checker: `scripts/mascot_contract.py`
- math engine: `scripts/bake_mascot.py`
- worker: `agents/mascot-animator.md`

## Research gates

Apply `mascot-identity` to preserve exact mascot geometry, source provenance, and identity status. Apply `motion-on-weak-still` and `decorative-motion` to keep character motion meaningful and inside the motion budget.

---
name: masterone
description: Front-door onboarding and routing parent workflow for LinkedIn Animated Infographics. Use first when a user starts or resumes infographic work so reusable project preferences are loaded, missing blockers are resolved, and the correct canonical workflow is selected.
argument-hint: "[request, topic, URL, file, or focused task]"
---

# /linkedin-animated-infographics:masterone

Request: **$ARGUMENTS**

## Purpose

MasterOne is the first user-facing parent workflow for this plugin. It prepares reusable project context, resolves only the missing blockers that matter to the current request, then transfers control to the canonical production or focused workflow.

Read `helper/GUIDE.md` and `helper/router.json` before making a routing decision. Machine-readable contracts remain authoritative.

MasterOne does not replace `new-post`. Complete post production still belongs to the existing `new-post` parent workflow and its worker sequence.

## Use when

Use MasterOne when:

- this is the first LinkedIn Animated Infographics request in a project
- the user wants to create, redesign, inspect, render, study, animate, or share infographic work
- the project has reusable preferences such as footer copy, fonts, references, logos, or mascots
- an AI client needs one entrypoint before selecting a plugin skill or worker
- a prior profile exists and should be reused instead of asking the same setup questions again

A client may invoke a focused workflow directly only when the request is already unambiguous and no reusable project context is missing.

## Inputs

MasterOne may consume:

- the user's current request
- `.linkedin-infographics/profile.json` when present
- current `CLAUDE.md` / `AGENTS.md` instructions
- explicit user-provided logos, mascots, fonts, references, files, URLs, and brand assets
- safely observable project paths and existing files
- the route registry in `helper/router.json`

Reusable profile fields include:

- project name and brand
- default language and audience
- copyright owner, attribution, footer text, and whether a footer is required
- primary, secondary, and Arabic fonts plus local font paths
- approved logo and brand-asset paths
- visual references, reference directories, and whether references are inspiration, strict direction, or ask-first
- mascot identities, asset paths, and automatic-use policy
- static or animated output preference
- motion defaults
- approval and output-directory preferences

## Outputs

MasterOne returns or maintains:

- `.linkedin-infographics/profile.json`
- an onboarding/readiness summary with `READY` or the exact missing blocking fields
- one normalized route decision from the supported intent set
- a bounded `MASTERONE` managed section in `CLAUDE.md` when the client has file-write capability
- the canonical downstream parent or focused workflow selection

Supported downstream intents are:

- `create-post`
- `qa`
- `render`
- `design-study`
- `mascot-animation`
- `info-story`
- `share-demo`

## Procedure

### 1. Read authority before onboarding

Read `helper/GUIDE.md`, then `helper/router.json`.

If `.linkedin-infographics/profile.json` exists, read it before asking setup questions. Treat it as reusable project preference context, not as evidence for claims inside a post.

### 2. Inspect before asking

Inspect the user's request and available project context for explicit or safely observable values.

Examples of safely observable context:

- a logo file the user attached or explicitly named
- a local font file already supplied
- a reference directory the user explicitly pointed to
- an existing footer string already recorded in the project profile

Do not infer ownership, rights, attribution, identity, or creative intent from a filename alone.

### 3. Initialize the profile when missing

When the profile does not exist and file-write capability is available, create `.linkedin-infographics/profile.json` using `schemas/masterone-profile.schema.json` as the shape contract.

Start unknown preferences as `null`, empty arrays, or conservative defaults. Never fabricate values to make the profile look complete.

When file-write capability is unavailable, keep the same profile shape in working context and tell the parent client that persistence is unavailable for this run.

### 4. Resolve only route-relevant blockers

For `create-post`, reusable blocking preferences are:

- `content.default_language`
- `content.audience`
- `linkedin.output_mode`

When `copyright.footer_required` is true, `copyright.footer_text` is also blocking.

Fonts, references, logos, mascots, and other fields become blocking only when the request or an active downstream gate requires them.

Focused intents do not inherit unrelated onboarding requirements. A render-only request must not be blocked because audience is missing.

Ask one compact onboarding turn containing only the unresolved blocking fields. If the user provides multiple answers together, record all of them and do not ask again.

### 5. Persist reusable answers

Write reusable answers back to `.linkedin-infographics/profile.json` when file-write capability exists.

Keep transient post facts out of the profile. Topic-specific claims, one-off metrics, current URLs, and post-specific CTA wording belong to the existing runtime request and downstream evidence artifacts.

### 6. Keep CLAUDE.md bounded

When file-write capability exists, maintain one marker-bounded section:

`<!-- MASTERONE:START -->`

The managed section should point to `.linkedin-infographics/profile.json` and require clients to honor copyright/footer rules, fonts, approved identity assets, mascot policy, reference intent, language/RTL defaults, audience, and output mode.

End the section with:

`<!-- MASTERONE:END -->`

Replace only text inside those markers. Preserve all other `CLAUDE.md` content.

Do not copy the full profile JSON into `CLAUDE.md`.

### 7. Classify the request

Map the request to one existing intent:

- complete new post or substantial redesign -> `create-post`
- inspect a finished artifact -> `qa`
- render an approved HTML artboard -> `render`
- analyze a visual reference -> `design-study`
- animate a verified mascot SVG as a focused task -> `mascot-animation`
- compose or resolve an Info-story without the full post pipeline -> `info-story`
- publish a verified completed demo after explicit consent -> `share-demo`

Use the current router contract instead of guessing when route prose and registry data differ.

### 8. Transfer control

After onboarding is `READY`, transfer control to the route's existing parent or focused workflow.

For `create-post`, invoke `new-post` and preserve its complete production sequence.

MasterOne remains the user-facing coordinator for onboarding and route selection, but downstream workers return to their own parent workflow. MasterOne does not sequence peer workers inside `new-post`.

### 9. Re-onboard only when needed

On later requests, reuse the profile automatically.

Ask again only when:

- a required field is still missing
- the user explicitly changes a preference
- a route activates a new blocking requirement
- a stored path is no longer usable
- the stored preference conflicts with an explicit current request

Current explicit user instructions override reusable defaults for the current request. Persist the override only when the user indicates it should become the new default.

## HOLD conditions

Return a precise HOLD before route transfer when:

- a route-relevant blocking profile field is missing after inspection
- the profile is structurally invalid and cannot be safely repaired without user input
- a required footer is enabled but its exact text is unknown
- a requested font is required but unavailable under the existing render-safe typography contract
- a requested named logo or mascot cannot pass the existing verified-identity contract
- a requested reference has no usable evidence under the existing reference gate
- routing intent remains genuinely ambiguous after using the request and current profile

Do not invent a value to clear a HOLD.

## Related components

- routing authority: `helper/router.json`
- routing guide: `helper/GUIDE.md`
- profile schema: `schemas/masterone-profile.schema.json`
- complete production parent: `skills/new-post/SKILL.md`
- public deterministic routing helper: `skills/post/SKILL.md`
- plugin graph: `architecture/plugin-graph.json`
- module registry: `helper/modules.json`
- runtime request and caching: `scripts/runtime_context.py`

## Research gates

MasterOne does not add new research claims or quality gates. It activates the route already defined by the helper and preserves that route's existing research gates, local quality gates, verified-identity rules, typography rules, reference behavior, HOLD semantics, and bounded verification requirements.

For complete post creation, downstream `new-post` continues to apply `evidence-traceability` and `bounded-verification` with the rest of its active gate set.

---
name: motion
description: Design and implement deterministic seekable infographic motion that communicates reading order, state, reveal, hierarchy, or route direction while preserving a complete first frame and clean loop.
---

# Motion

## Purpose

Add meaning-driven motion to an already approved still. Motion should clarify sequence, hierarchy, route, state change, reveal, or the selected creative payoff. It is not a substitute for weak structure.

Read `helper/GUIDE.md` first. Rendered infographic animation is seeked frame-by-frame, not screen-recorded in real time.

## Use when

Use when choosing or implementing Motion Patterns, writing keyframes, animating routes or state changes, integrating mascot motion, debugging a loop, or diagnosing an oversized/jittery GIF caused by animation behavior.

## Inputs

- approved `build/still.png` and `build/post.html`
- selected creative concept and aha mechanic when present
- `build/story-brief.json`
- `build/layout-spec.json`
- `build/motion-direction.json` when produced by the motion director
- optional mascot motion contract
- target duration/fps from verified timing options

## Outputs

Return or support the animated `build/post.html`, resolved Motion Patterns, timing rationale, loop/motion-budget notes, and any HOLD that prevents deterministic capture.

## Procedure

1. Read `references/animation-recipes.md`, `references/hyperframes-motion-recipes.md`, `references/emil-craft-animation-rules.md`, `references/emil-complete-recipes.md`, `references/css-keyframe-patterns.md`, `references/impeccable-motion-craft.md`, `references/mblode-transition-recipes.md`, `references/animation-opportunities-gate.md`, and active helper gates.
2. Use one loop clock. Define `--loop` once and derive sub-animation durations with integer divisions. Do not mix arbitrary unrelated durations.
3. Frame 0 must be a complete readable still and the animation state at 0% and 100% must close.
4. Use at most two meaning-driven motion patterns for the infographic. A Mascot Pointer replaces another pointer primitive rather than adding a third competing route.
5. Available primitives include Sequential Highlight, Path Particles, Path Draw-On, Orbit, Staggered Reveal, Bar Growth, Typewriter, Glow Pulse, Ambient Micro-Loops, Mascot Pointer, Kinetic Beat Slam, Dynamic Countup/Chart Scrub, Anchored Layout Expand, Spring-Pop Overshoot, Tactile Press, Origin-Aware Popovers, Container Morph, Odometer Roll, and Ballistic Particles.
6. Tie motion to the selected concept's useful payoff. A reveal, state transition, route, or comparison can support `creative-payoff`; decorative movement that does not change understanding should stay static.
7. Keep changed pixels under control. Large blur, backdrop-filter, large shadow spread, and full-canvas decorative motion are poor choices for GIF encoding.
8. Respect the reverse-delay rule for sequential animation. Verify order by capturing quarter-cycle frames instead of trusting intuition.
9. Keep the outer 48px safe zone static and preserve reduced-motion behavior where the delivery context supports it.
10. Render with verified timing rows:

```bash
bash ${CLAUDE_PLUGIN_ROOT}/scripts/render.sh build/post.html build/post.gif --duration 6.0 --fps 12.5
```

11. Read seam and changed-pixel evidence before approving the motion.

## HOLD conditions

Return a HOLD when the still is not approved, frame 0 is incomplete, the loop cannot close deterministically, motion contradicts the approved reading order, the requested effect exceeds the motion budget, or a mascot path lacks a validated exact-SVG component.

## Related components

- routing authority: `helper/GUIDE.md`
- local quality gates: `helper/quality-gates.json`
- motion recipes: `references/animation-recipes.md`, `references/hyperframes-motion-recipes.md`, `references/emil-craft-animation-rules.md`, `references/emil-complete-recipes.md`, `references/css-keyframe-patterns.md`, `references/impeccable-motion-craft.md`, `references/mblode-transition-recipes.md`, `references/animation-vocabulary.md`, and `references/animation-opportunities-gate.md`
- motion planner: `agents/motion-director.md`
- implementation worker: `agents/motion-engineer.md`
- mascot skill: `skills/mascots/SKILL.md`
- render skill: `skills/render/SKILL.md`

## Research gates

Apply `design-dials` when resolving motion intensity and `bounded-verification` when the animated result reaches render/acceptance. `structural-originality` remains relevant when motion behavior is part of the story fingerprint.

---
name: new-post
description: Run the complete evidence-to-delivery workflow for a static or animated LinkedIn infographic, including verified identity sourcing, creative concepting, typography direction, story architecture, production, critique, and independent verification.
disable-model-invocation: true
argument-hint: "[topic or URL] [optional: --arabic] [optional: --mascot]"
---

# /linkedin-animated-infographics:new-post

Topic: **$ARGUMENTS**

## Purpose

Run the canonical parent workflow for a complete LinkedIn infographic. The workflow owns routing, user approvals, HOLD resolution, targeted repair loops, and final delivery. Workers return bounded artifacts here and never coordinate peer workers directly.

Read `helper/GUIDE.md` before execution. Treat `helper/router.json`, `helper/capabilities.json`, `helper/quality-gates.json`, `helper/artifacts.json`, `research/capability-notes/gates.json`, and `architecture/plugin-graph.json` as machine-readable contracts.

## Use when

Use this workflow when the user wants a complete new infographic or a substantial redesign that should proceed from source/evidence through verified assets, concept, type, copy, artboard, optional motion, QA, and delivery.

Use focused skills instead when the request is only a render, only QA, only mascot animation, only a design study, or only publishing an already verified demo.

## Inputs

- topic, source material, URL, files, or user-provided facts
- intended audience and one primary takeaway when they cannot be inferred safely
- desired CTA when applicable
- language and static/animated output preference
- optional visual references
- optional brand/UI assets
- optional exact official identity assets or named AI/tool identities that may resolve through Lobe
- explicit typography requirements when present

## Outputs

The parent workflow may produce:

- `build/design-study.json`
- `build/evidence.json`
- `build/asset-plan.json`
- `build/creative-concepts.json`
- `build/story-brief.json`
- `build/palette-check.json`
- `build/type-spec.json`
- `build/artboard-copy.json`
- `build/layout-spec.json`
- `build/caption.md`
- `build/first-comment.md`
- `build/post.html`
- `build/still.png`
- `build/motion-direction.json` for animated output
- `build/mascot/motion-contract.json` when a mascot is active
- `build/render-report.json`
- `build/critic-report.json`
- `build/verification-report.json`
- final static/GIF artifact plus resolved story and validation summary

## Procedure

### 0. Route and conditional gates

Resolve the request through the helper. Apply local quality gates and research gates before production.

If Arabic/RTL is active, load the `arabic` skill before copy or layout work.

If a named or official mascot is requested, record `build/mascot-request.json`. The identity is not allowed to bypass the verified identity path. Exact user/task SVG assets keep priority; supported AI/tool identities may resolve from Lobe; unresolved named identities HOLD.

### 1. Reference diagnosis

Consume `reference_diagnosis` from the helper before evidence inventory:

- `SKIP`: no reference was supplied; do not invoke `design-study`.
- `HOLD`: explicit reference intent has no usable `reference_evidence`; stop before `evidence-checker` with `HOLD: reference evidence unavailable`.
- `READY`: invoke `design-study` as the first worker and save `build/design-study.json`. Activate `reference-dna` and study reusable structure, hierarchy, rhythm, density, type roles, and motion grammar without cloning distinctive work.

Downstream workers receive only the selected mechanism IDs and the focused stage context from `build/design-study.json`, never the full reference library or raw reference media.

### 2. Evidence inventory

Delegate to `evidence-checker`. Save `build/evidence.json` with protected claims, metrics, product states, named identities, logos, proof, and unsupported slots. Unsupported proof is blocked before creative/copy/layout production.

### 3. Verified identity asset plan

Delegate to `asset-curator`. Save `build/asset-plan.json`.

Apply `verified-identity-assets` and `skills/info-stories/references/asset-source-policy.md`. Exact user-supplied official assets win. For supported named AI/tool identities, the worker reads `https://lobehub.com/icons/skill.md` and follows the current Lobe instructions. Final production assets must be local or embedded. If a named identity cannot be verified, stop with `HOLD: verified identity asset required` instead of generating a lookalike.

### 4. Creative concept directions

Delegate to `creative-director` with the evidence record, asset plan, optional design study, audience, language, output mode, and approved constraints. Save `build/creative-concepts.json`.

Require at least three meaningfully different directions. Every direction contains a visual hook, copy hook, aha mechanic, story relationship, dominant visual anchor, structure/archetype, containment strategy, negative-space strategy, motion job, evidence dependencies, risk notes, and why it earns attention.

Apply `hooked-design-copy`, `creative-payoff`, and `clean-creative-structure`. When the story permits, include an editorial low-containment option. When a real relationship exists, include a diagrammatic or relationship-led option. Repeated cards are valid only when repeated units are the story.

The parent workflow selects or approves one direction before story architecture.

### 5. Story contract

Delegate to `story-architect` with the selected concept, evidence, optional design study, one takeaway, CTA, language, and output mode. Save `build/story-brief.json` with Story House, Visual Style, Story Archetype, Motion Patterns, design dials, clean-structure requirements, and execution bridge.

### 6. Palette contract

Delegate to `palette-curator`. Save `build/palette-check.json`.

The plugin default is `creative-attractive-restrained`: use an engaging, memorable, harmonious palette without exaggerated saturation, unnecessary neon, or competing accents unless the approved brief explicitly calls for them. Text/state contrast floors remain blocking.

### 7. Typography contract

Delegate to `type-curator`. Save `build/type-spec.json`.

Apply `intentional-typography` and `skills/info-stories/references/typography-direction.md`. User-specified typography wins when render-safe, followed by supplied/bundled local assets, then a curated deterministic system direction. Remote @import or another render-time font request is blocking.

### 8. Artboard copy

Delegate to `copy-compressor` with evidence, selected concept, type spec, story brief, and target slots. Save `build/artboard-copy.json`. The hero and attention-bearing story openers must use evidence-safe hooks; literal labels remain literal where clarity wins. Copy must fit the type-spec minimum feed sizes without silent font substitution.

### 9. Static layout specification

Delegate to `layout-composer`. Save `build/layout-spec.json` with zone order, proportions, visual anchor, component counts, structural fingerprint, clean-structure requirements, verified asset placements, exact type roles, alignment mode, and any exception reason.

Use `center-first` for the primary visual anchor and major story zones. A non-centered alignment requires a recorded comprehension/fidelity reason such as tables, UI mockups, code/terminal surfaces, timelines, Arabic/RTL flow, or reference-DNA fidelity.

### 10. Caption

Delegate to `caption-writer`. Save `build/caption.md` and `build/first-comment.md`. The opening hook must be specific and evidence-safe. Show the caption and selected story direction for approval before still construction when interactive approval is available.

### 11. Still construction

Delegate to `artboard-builder` with the approved story, asset plan, type spec, palette, copy, layout, and caption artifacts. It returns `build/post.html` and `build/still.png` after source, typography, and static checks. Show the still as the visual approval gate when interaction is available.

### 12. Motion direction

For animated output, delegate to `motion-director` with the approved still, selected concept, story brief, layout spec, and mascot role when applicable. Save `build/motion-direction.json`. Static output records this stage as skipped.

### 13. Mascot component when active

After still construction and before motion implementation, delegate the verified identity SVG to `mascot-animator`. The source may be exact user/task input or a verified Lobe asset already copied locally by `asset-curator`. Save identity and rig evidence plus `build/mascot/motion-contract.json`. The verified SVG remains the identity source.

### 14. Motion implementation

For animated output, delegate to `motion-engineer` with the approved still, story brief, motion direction, and mascot contract when present. It returns the animated `build/post.html`. Static output skips this stage.

### 15. Render mechanics and QA

Delegate to `render-qa`. Save `build/render-report.json`. A render HOLD returns control to this parent workflow for a targeted fix and re-run.

### 16. Adversarial review

Delegate to `post-critic` with the artifact, caption, evidence, asset plan, type spec, selected concept, layout, mascot identity notes when present, and render report. Save `build/critic-report.json`.

The critic explicitly evaluates `hooked-design-copy`, `creative-payoff`, `clean-creative-structure`, `verified-identity-assets`, `intentional-typography`, `restrained-palette`, and `center-first-composition` in addition to applicable research gates.

### 17. Independent acceptance

Delegate to `story-verifier`. Save `build/verification-report.json`. The verifier reads artifacts directly, including identity provenance and typography. `FAIL:fixable` may trigger a targeted fix and re-check. Maximum two targeted repair attempts; a third unresolved failure escalates.

### 18. Deliver

Deliver the final artifact, caption, first comment, resolved Info-stories choices, selected creative concept, identity source summary, type direction, render numbers when applicable, active gate summary, and final verification verdict.

### 19. Share with the community (optional)

Offer community sharing only when the final verification verdict is `PASS` and delivery is complete.

Ask one concise opt-in question: `Share this demo with the community?`

If the user explicitly accepts, transfer control to the focused parent workflow `share-demo`. That workflow owns publication metadata, rights confirmation, public-export preflight, source-prompt consent, packaging, and delegation to `community-publisher` for fork/branch/commit/push/PR mechanics.

If the user declines or gives no answer, stop with no GitHub write. Do not repeat the offer or infer consent from the fact that the user created the demo.

If `share-demo` later returns a HOLD, preserve the already delivered artifact and report only the publication blocker. A publication HOLD does not invalidate the completed post.

## HOLD conditions

Stop and return a precise HOLD when any blocking production requirement is unresolved, including:

- missing verified identity asset for a named AI/tool/logo/mascot
- Lobe coverage cannot be verified for a required supported identity
- final identity asset is remote-only instead of local/embedded
- typography depends on a remote font request or cannot meet feed-scale legibility
- unsupported factual proof, metric, product state, logo, or claim
- hook or aha concept depends on invented evidence
- selected concept fails `clean-creative-structure`
- failing contrast or Story House compatibility
- unresolved blocking local quality gate
- unresolved blocking research gate
- render evidence unavailable when required
- third unresolved verification failure after two targeted repair attempts

The optional community-sharing stage does not create a production HOLD when the user declines or gives no answer. If the user opts in, publication-specific HOLD conditions are owned by `share-demo`.

Do not fill missing inputs with plausible content.

## Related components

- helper: `helper/GUIDE.md`
- router: `helper/router.json`
- local gates: `helper/quality-gates.json`
- artifacts: `helper/artifacts.json`
- executable graph: `architecture/plugin-graph.json`
- identity source policy: `skills/info-stories/references/asset-source-policy.md`
- typography policy: `skills/info-stories/references/typography-direction.md`
- creative copy reference: `skills/info-stories/references/hook-driven-design-copy.md`
- design defaults: `skills/info-stories/references/design-taste-gates.md`
- focused QA: `qa-post`
- focused render: `render-gif`
- optional community publisher: `share-demo`

## Research gates

Complete post creation may activate `prose-specificity`, `voice-preservation`, `design-dials`, `structural-originality`, `reference-dna`, `contrast-discipline`, `evidence-traceability`, and `bounded-verification` according to `research/capability-notes/gates.json`.

The final safety gates include identity provenance, typography render safety, `evidence-traceability`, and `bounded-verification`. They remain active even when the chosen creative direction is intentionally simple. The optional `share-demo` workflow inherits the final PASS as a publication prerequisite.

---
name: post
description: Route LinkedIn infographic requests to the correct complete or focused workflow using the repository helper, capability gates, creative defaults, and artifact contracts.
---

# LinkedIn Animated Infographics

## Purpose

Act as the lightweight **routing entrypoint** for the plugin. Do not duplicate the complete workflow here. Read `helper/GUIDE.md`, classify the request, inspect the route, then invoke the correct workflow or focused skill.

## Use when

Start here for a LinkedIn infographic, post, GIF, cheat sheet, workflow visual, stack map, UI story, design direction, hook, mascot request, render request, or QA request when the correct specialist path is not already explicit.

## Inputs

- user request and source material
- optional intent override
- language/output mode
- optional visual references, UI mockup flag, brand assets, or mascot requirement

## Outputs

Return a resolved route containing workflow, skills, agents, capabilities, asset gates, research gates, and local quality gates. For creation requests, hand control to the `new-post` parent workflow.

## Procedure

1. Read `helper/GUIDE.md`.
2. Resolve the request through the deterministic helper when structured routing is useful:

```bash
python3 ${CLAUDE_PLUGIN_ROOT}/tools/route_request.py --request "<request>"
```

3. Use the route intent:
   - `create-post` → `new-post`
   - `qa` → `qa-post`
   - `render` → `render-gif`
   - `design-study` → focused `design-study` worker/Info-stories references
   - `mascot-animation` → `mascots` + `svg-mascot-animator`
   - `info-story` → focused `linkedin-animated-infographics:info-stories` composition path
4. When Info-stories is active, the resolved Story House from the merged registry is authoritative. Do not silently replace it with legacy House 0; House 0 is only a legacy fallback when there is no resolved story brief.
5. Apply conditional gates before production: Arabic/RTL, UI fidelity, visual-reference diagnosis, and exact official mascot SVG.
6. For complete creation, require the `creative-director` concept stage before `story-architect`. The concept should provide evidence-safe visual/copy hooks and a useful aha mechanic rather than a generic topic restatement.
7. Keep plugin-local defaults active: `creative-attractive-restrained` palettes and `center-first` composition with documented exceptions.
8. Do not silently bypass `post-critic` or `story-verifier` on complete shipping paths.

## HOLD conditions

Return a HOLD when the helper reports a blocking asset or gate, especially a missing exact mascot SVG, unsupported evidence, incompatible Story House/Style choice, or a render/verification blocker. Do not invent a route around a blocking gate.

## Related components

- routing authority: `helper/GUIDE.md`
- router registry: `helper/router.json`
- capability registry: `helper/capabilities.json`
- local quality gates: `helper/quality-gates.json`
- artifact contracts: `helper/artifacts.json`
- research gates: `research/capability-notes/gates.json`
- Info-stories skill: `linkedin-animated-infographics:info-stories`
- complete workflow: `skills/new-post/SKILL.md`
- focused QA: `skills/qa-post/SKILL.md`
- focused render: `skills/render-gif/SKILL.md`

## Research gates

The post router does not reinterpret research rules. It passes through the gate IDs returned by the helper, including `prose-specificity`, `voice-preservation`, `design-dials`, `structural-originality`, `reference-dna`, `contrast-discipline`, `evidence-traceability`, and `bounded-verification` where applicable.

---
name: qa-post
description: Run deterministic render checks, local creative gates, adversarial critique, and independent evidence-backed acceptance against a built infographic before shipment.
disable-model-invocation: true
argument-hint: "[path/to/artboard.html] [optional: path/to/caption.md]"
---

# /linkedin-animated-infographics:qa-post

Arguments: **$ARGUMENTS**

## Purpose

Act as the focused **parent workflow** for QA. Report evidence and route targeted fixes; do not silently edit the artifact or let the producing worker grade its own result.

Read `helper/GUIDE.md` before checking the artifact.

## Use when

Use for a finished or nearly finished artboard/GIF that needs shipping acceptance, regression review, visual/caption red-teaming, or verification after a targeted fix.

## Inputs

- artboard HTML and rendered static/GIF evidence
- optional caption and first comment
- story brief, selected creative concept, evidence table, and layout spec when available
- optional mascot identity/motion contract
- explicit acceptance criteria when supplied

## Outputs

Return `build/render-report.json`, `build/critic-report.json`, `build/verification-report.json`, and one final verdict: `SHIP` or `HOLD: <the one thing to fix first>`.

## Procedure

1. Run deterministic render checks:

```bash
bash ${CLAUDE_PLUGIN_ROOT}/scripts/lint_artboard.sh <path>
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/artboard_audit.py <path> --json /tmp/artboard-audit.json
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/check_render.py <path> --out /tmp/qa-still.png --mobile --json /tmp/still-audit.json
```

2. Walk the `render` skill and `references/qa-gates.md`. Inspect frame 0 and feed-width output. For GIFs, use `render.sh` so lint, measured artboard/still/GIF fragments, and the merged `build/render-report.json` are all produced.
3. If a caption exists, apply the `caption` skill and `hooked-design-copy`. Check truncation, one archetype, factual support, CTA discipline, and anti-slop findings.
4. Delegate adversarial review to `post-critic`. It must evaluate `creative-payoff`, `restrained-palette`, `center-first-composition`, UI fidelity, mascot identity when present, motion meaning, and evidence safety.
5. Any must-fix item produces a HOLD until corrected or proven not applicable.
6. Delegate independent acceptance to `story-verifier`. The verifier reads the actual artifacts and evidence, not a worker summary.
7. Respect the maximum-two targeted fix attempts before escalation.

## HOLD conditions

Return HOLD for a failed render gate, unsupported factual claim, generic/unsupported hero hook, missing promised creative payoff, excessive or unjustified palette treatment, invalid alignment exception, UI/mascot fidelity failure, or independent verifier failure.

## Related components

- routing authority: `helper/GUIDE.md`
- local quality gates: `helper/quality-gates.json`
- render skill: `skills/render/SKILL.md`
- caption skill: `skills/caption/SKILL.md`
- adversarial worker: `agents/post-critic.md`
- independent verifier: `agents/story-verifier.md`
- verification reference: `skills/info-stories/references/verification-loop.md`

## Research gates

QA enforces applicable `prose-specificity`, `voice-preservation`, `structural-originality`, `contrast-discipline`, and `evidence-traceability` gates. `bounded-verification` is always active for final acceptance and prevents unbounded repair loops.

---
name: render-gif
description: Render an existing infographic artboard HTML to a deterministic looping GIF, then report motion, seam, and file-size evidence without changing the approved design.
disable-model-invocation: true
argument-hint: "[path/to/artboard.html] [--duration 6.0] [--fps 12.5]"
---

# /linkedin-animated-infographics:render-gif

Arguments: **$ARGUMENTS**

## Purpose

Provide a **focused workflow** for rendering an already approved artboard. This workflow does not redesign copy, layout, palette, or motion direction; it turns the existing artifact into deterministic GIF evidence.

Read `helper/GUIDE.md` first.

## Use when

Use when the user already has artboard HTML and wants the GIF output, wants a render rerun after a targeted fix, or needs the three core render measurements without running the entire new-post workflow.

## Inputs

- path to approved artboard HTML
- optional duration/fps override
- desired output path and file-size budget

## Outputs

Return the rendered GIF plus motion percentage/verdict, seam result, file size, and any HOLD that prevents a trustworthy render.

## Procedure

1. If no path is supplied, locate candidate `build/*.html` artifacts and ask/select rather than guessing.
2. Lint before rendering:

```bash
bash ${CLAUDE_PLUGIN_ROOT}/scripts/lint_artboard.sh <path>
```

3. If duration/fps are not supplied, use a verified timing row from the `motion` skill. Do not invent arbitrary timings that cannot close cleanly.
4. Render:

```bash
bash ${CLAUDE_PLUGIN_ROOT}/scripts/render.sh <path> <out.gif> --duration <d> --fps <f>
```

5. Inspect `motion:`, seam, and file size. If the seam fails, use the motion debugging reference to identify the likely cause instead of guessing.
6. Return the GIF and concise render evidence. Do not add a design postamble that implies unperformed QA.

## HOLD conditions

Return a HOLD when lint fails, browser capture is unavailable, frame 0 is invalid, the loop seam fails, output exceeds the accepted budget after controlled fallback, or the render evidence cannot be produced reliably.

## Related components

- routing authority: `helper/GUIDE.md`
- domain render skill: `skills/render/SKILL.md`
- motion skill: `skills/motion/SKILL.md`
- render worker: `agents/render-qa.md`
- full QA workflow: `skills/qa-post/SKILL.md`

## Research gates

`bounded-verification` applies to render failure/re-check behavior. The workflow reports evidence and does not silently mutate the artifact to force a PASS.

---
name: render
description: Capture deterministic infographic frames, assemble GIF output, measure motion/seam/file size, and run the render acceptance gates before shipment.
---

# Render and ship

## Purpose

Convert an approved static/animated artboard into deterministic render evidence and final GIF output. Rendering is an acceptance stage, not a place to redesign the story.

Read `helper/GUIDE.md` first. Render evidence feeds `post-critic` and `story-verifier` through `build/render-report.json`.

## Use when

Use when capturing frames, building a GIF, diagnosing blank/jittery/oversized output, measuring seam or changed pixels, running render QA, or preparing a final LinkedIn image GIF.

## Inputs

- approved `build/post.html`
- duration/fps from verified motion timing when animated
- output file-size budget
- expected frame-zero state and safe-zone constraints

## Outputs

Return GIF/static render output plus `build/render-report.json` containing frame-zero, mobile legibility, motion percentage, seam result, duration/fps, file size, and any blocking render finding.

## Procedure

1. Use the one-command path when possible:

```bash
bash ${CLAUDE_PLUGIN_ROOT}/scripts/render.sh build/post.html build/post.gif --duration 6.0 --fps 12.5
```

2. The underlying deterministic stages are:

```bash
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/capture_frames.py build/post.html --out build/frames --duration 6.0 --fps 12.5 --selector "#artboard"
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/build_gif.py build/frames --out build/post.gif --fps 12.5 --max-mb 5 --colors 128
```

3. Read `references/qa-gates.md`, `references/production-pipeline.md`, and `references/pixel-perfect-browser-inspection.md`.
4. Inspect three core measurements: mean changed-pixel `motion:`, loop seam relative to normal frame deltas, and file size.
5. Treat frame 0 as a complete poster frame. It must remain readable before autoplay.
6. Inspect the 350px feed downscale honestly. Render success without feed-scale legibility is not acceptance.
7. Keep the outer 48px safe zone free of motion and account for known SVG `<defs>` false positives when diagnosing geometry.
8. If encoding exceeds the budget, prefer the existing controlled color/fps/scale fallback rather than arbitrary re-authoring.
9. For publishing guidance, read `references/publishing-playbook.md`: LinkedIn GIF output is uploaded as an image; links normally belong in the first comment when the post strategy calls for them.

## HOLD conditions

Return a HOLD when capture fails, frame 0 is incomplete, the seam does not close, changed-pixel motion indicates unintended full-canvas animation, feed-scale output is unreadable, safe-zone rules fail, or output cannot fit the accepted file budget without unacceptable degradation.

## Related components

- routing authority: `helper/GUIDE.md`
- focused render workflow: `skills/render-gif/SKILL.md`
- motion skill: `skills/motion/SKILL.md`
- QA gates: `references/qa-gates.md` and `references/pixel-perfect-browser-inspection.md`
- production setup: `references/production-pipeline.md`
- render worker: `agents/render-qa.md`
- independent verifier: `agents/story-verifier.md`

## Research gates

`bounded-verification` governs how render failures enter the repair/re-check loop. `contrast-discipline` remains relevant to rendered evidence, and `evidence-traceability` applies when the final artifact contains factual proof that must be checked visually.

---
name: share-demo
description: Package a verified infographic demo for the public gallery and, after explicit user opt-in, prepare a community pull request without merging it.
disable-model-invocation: true
argument-hint: "[build directory] [optional metadata]"
---

# /linkedin-animated-infographics:share-demo

## Purpose

Run the focused parent workflow for publishing a finished infographic to the repository community gallery. This is a public data-export boundary, not part of normal delivery. Read `helper/GUIDE.md` before execution and keep all GitHub writes behind explicit opt-in.

The public demo contract is exactly `demo.gif + index.html + demo.json`. `demos/catalog.json` is generated separately and is never a fourth file inside a demo directory.

## Use when

Use this focused workflow only when a user explicitly agrees to share a finished demo with the community, or directly asks to publish a previously verified result. The normal `new-post` parent workflow may offer this after delivery only when final verification PASS has already been recorded.

Do not invoke this workflow merely because a GIF was generated. Declining the offer, giving no consent, or asking only for local output causes no GitHub write.

## Inputs

Required inputs:

- explicit opt-in to public community sharing
- `build/post.html` or another explicitly selected final verified HTML artifact
- `build/post.gif` or another explicitly selected final verified GIF artifact
- `build/verification-report.json` with final verdict `PASS`
- GitHub username and matching public author URL
- demo title and short description
- language, story type, and tags
- explicit rights confirmation covering the submitted HTML, GIF, and redistributable assets
- chosen public license

Optional inputs:

- source prompt, only when the user separately consents to publishing it
- source repository URL
- short public notes

## Outputs

The parent workflow produces:

- `build/community-demo.json` containing the approved public metadata
- `build/community-demo-package` containing the staged three-file package
- on successful GitHub publication, a pull request URL against `imMamdouhaboammar/linkedin-animated-infographics:main`
- on unavailable GitHub write access, a precise HOLD plus the validated local contribution package and manual commands when the host can prepare them safely

A PR URL is required before reporting GitHub publication as successful. Creating files locally is not equivalent to opening a pull request.

## Procedure

1. Confirm **explicit opt-in**. Ask one direct question if consent is not already explicit. Do not infer consent from enthusiasm, prior GitHub use, or the fact that the user created the work.
2. Read `build/verification-report.json`. Community publication requires **verification PASS**. Any other verdict returns a HOLD.
3. Resolve the exact final HTML and GIF. Do not publish drafts, stills, evidence files, build reports, attachments, or unrelated files.
4. Collect publication metadata: title, author, author URL, description, language, story type, tags, date, plugin version, and license.
5. Obtain explicit **rights confirmation**. Do not infer ownership or redistribution rights.
6. Treat the **source prompt** as private by default. Include it only after a separate explicit yes to publishing the prompt itself.
7. Write the approved metadata input used by the deterministic preflight. Keep control fields such as prompt-consent flags outside the final public schema.
8. Prepare the contribution package with `scripts/demo_submit.py prepare`, for example:

```bash
python3 scripts/demo_submit.py prepare \
  --build-dir build \
  --stage-root build/community-submission \
  --author <github-user> \
  --slug <slug> \
  --metadata build/community-demo.json
```

9. Validate the staged package with `scripts/demo_submit.py check`:

```bash
python3 scripts/demo_submit.py check build/community-submission/community/<github-user>/<slug>
```

10. Run the gallery validator against the contribution checkout before GitHub publication. The required gate is `scripts/demo_gallery.py check`; regenerate `demos/catalog.json` deterministically with `scripts/demo_gallery.py build` only after the three-file package is placed in the contribution checkout.
11. Confirm the contribution changes only `demos/community/<github-user>/<slug>/{demo.gif,index.html,demo.json}` plus the root generated `demos/catalog.json` when its content changes.
12. Delegate the validated contribution to `community-publisher`. That worker owns fork, branch, commit, push, and pull-request mechanics. It returns control to this parent workflow and never merges.
13. Return the PR URL, demo ID/path, validation summary, and the explicit reminder that maintainer manual review and merge are still required.

## HOLD conditions

Return HOLD instead of guessing or partially publishing when any of these is unresolved:

- explicit opt-in is missing
- final verification PASS is missing
- final GIF or HTML is missing, empty, or ambiguous
- rights confirmation is missing or false
- public metadata is incomplete
- secret, local-path, signed-URL, or unsafe remote-script findings appear in export preflight
- the destination demo already exists
- GitHub username cannot be resolved safely
- GitHub authentication cannot create/reuse a fork, push a fresh branch, or open a pull request
- the target upstream repository cannot be verified exactly
- deterministic catalog validation fails

A HOLD must state the blocking requirement. Never weaken export checks, publish extra files, or claim success without a returned PR URL.

## Related components

- routing authority: `helper/GUIDE.md`
- route registry: `helper/router.json`
- demo schema: `schemas/demo.schema.json`
- package preflight: `scripts/demo_submit.py`
- gallery validator: `scripts/demo_gallery.py`
- gallery index: `demos/catalog.json`
- publisher worker: `agents/community-publisher.md`
- final creation parent workflow: `skills/new-post/SKILL.md`
- artifact registry: `helper/artifacts.json`

## Research gates

`bounded-verification` remains the relevant research gate because a demo cannot cross this export boundary until the independent final verdict is PASS. Existing evidence and creative gates govern the artifact before publication; this workflow does not create new claims, redesign the post, or reinterpret evidence.

---
name: svg-mascot-animator
description: Animate an exact SVG mascot, logo, icon, or character with identity-preserving, rig-aware, professional motion for deterministic or runtime delivery tracks.
license: MIT
---

# SVG Mascot Animator

## Purpose

Animate the exact supplied SVG while preserving identity-critical geometry, colors, marks, proportions, and recognizable details. Animation adds behavior around the user's asset; it does not redesign the mascot.

Read `helper/GUIDE.md` first. For named or official mascots, the exact-SVG gate is mandatory.

## Use when

Use when the user supplies an SVG for animation, names an official mascot that must be used exactly, requests believable mascot motion, or needs a mascot component for an Info-story or interactive web context.

## Inputs

- exact user-supplied/task-attached SVG when identity must be preserved
- validated `build/mascot-request.json` when used in the infographic workflow
- approved communication job and creative direction
- output track: deterministic baked/static or runtime interactive
- approved layout/motion constraints when embedded in an infographic

## Outputs

Return animated asset/component, inspection report, chosen creative direction, physics/timing rationale, identity-preservation notes, rig limitations, and the motion contract/evidence needed by downstream motion, render, critique, and verification workers.

## Procedure

1. For a named or official mascot, require the **exact SVG** before animation begins. Keep an untouched copy of the source.
2. If the exact SVG is missing in the main conversational context, **ask the user to upload the exact SVG** and stop. Inside a worker, return `HOLD: exact SVG required` to the parent workflow.
3. Validate the request contract:

```bash
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/mascot_contract.py check build/mascot-request.json
```

4. Inspect the SVG before promising articulation:

```bash
python3 ${CLAUDE_PLUGIN_ROOT}/skills/svg-mascot-animator/scripts/inspect_svg.py <path-to-svg>
```

Record viewBox, bounds, IDs, groups, transforms, clips, paths, and addressable parts. Do not silently split identity-critical geometry to fake articulation.
5. Choose the delivery track. Deterministic self-contained SVG/CSS/SMIL is the default for LinkedIn GIFs and frame capture. Runtime Anime.js is valid only when the target environment genuinely supports interaction.
6. Read `references/creative-directions.md`, `references/rigging.md`, `references/physics.md`, `references/animejs.md`, and `references/contract.md` as needed.
7. Define the motion job before keyframes. Specify communication purpose, exact existing SVG parts allowed to move, optional non-identity support elements, loop/reset behavior, and motion budget.
8. Use believable relationships such as projectile paths, damped landing reactions, pendulum timing for genuine swings, contact shadows derived from height, velocity-linked squash/stretch, anticipation, and follow-through only on addressable parts.
9. Avoid constant bouncing, random blinking, large rotations, unmotivated floating, or deformation that changes the mascot's identity.
10. Support elements such as route lines, cursors, cards, badges, or contact shadows must remain visually separate from the identity source and removable without changing the official mascot.
11. Verify the output:

```bash
python3 ${CLAUDE_PLUGIN_ROOT}/skills/svg-mascot-animator/scripts/check_asset.py <output.svg>
python3 ${CLAUDE_PLUGIN_ROOT}/skills/svg-mascot-animator/scripts/check_asset.py --runtime <scene.html>
```

12. Compare the result with the untouched source and confirm identity, purpose, loop closure, frame-zero readability when used in an infographic, reduced-motion behavior, accessible labeling, namespaced IDs/keyframes, and zero accidental network dependencies for baked assets.

## HOLD conditions

Return a HOLD when the exact SVG is missing, the requested articulation is impossible without identity-changing redraw, required brand details are ambiguous, the runtime track is requested in an environment that cannot support it, or the requested motion would violate the infographic's approved reading order or evidence boundary.

## Related components

- routing authority: `helper/GUIDE.md`
- infographic mascot skill: `skills/mascots/SKILL.md`
- focused worker: `agents/mascot-animator.md`
- request validator: `scripts/mascot_contract.py`
- creative directions: `references/creative-directions.md`
- rigging: `references/rigging.md`
- physics: `references/physics.md`
- asset contract: `references/contract.md`

## Research gates

Mascot identity/rigging is a local-native capability. When embedded in the complete infographic route, inherit applicable `design-dials`, `structural-originality`, `evidence-traceability`, and `bounded-verification` gates from the parent workflow.