HTML D3 Anime Video Workflow

Core Workflow

In isolated validation workspaces, read
```
../prompt.md
```
directly first when it exists; do not probe for it with shell-specific commands such as PowerShell
```
Get-ChildItem
```
or
```
Test-Path
```
in a bash runtime, and do not read
```
README.md
```
as a prompt substitute. The isolated
```
pi
```
shell is bash; a PowerShell probe in bash is validation noise. Treat
```
../prompt.md
```
as the path and command contract before inspecting optional references. Reading
```
SKILL.md
```
does not satisfy a prompt-reading requirement. If the prompt says to run an exact command or gives a fenced command for a required video scaffold or validation artifact, run that command verbatim immediately after reading the prompt from the current workspace root; do not prepend
```
cd /mnt/data
```
,
```
cd .
```
,
```
pwd
```
, or any other directory-changing/probing command. For render, browser, ffmpeg, or Metro audit commands, set the shell tool timeout to at least 600 seconds so successful long-running visual audits do not become validation-noise retries. Do not replace concrete paths with placeholders, infer alternate project IDs, inspect target script source, or list directories with
```
Get-ChildItem
```
,
```
ls
```
,
```
dir
```
,
```
find
```
, or
```
pwd
```
first. Do not ask questions, read optional references, open helper script source, or stop after reading the skill file before that command runs. Do not read
```
scripts/build_standalone_explainer.py
```
,
```
scripts/build_from_prompt_contract.py
```
,
```
scripts/run_metro_audit_suite.py
```
, any
```
scripts/audit_metro_*.py
```
, or
```
scripts/check_video_outputs.py
```
during normal task use unless the task is to modify or debug those scripts. After the command finishes, verify the exact requested paths and only then refine or respond.
- If
```
../prompt.md
```
  gives an exact command, run that exact command first. Otherwise, if
```
../prompt.md
```
  contains
```
Required exact outputs
```
  , run this fast lane immediately and do not open the wrapper, suite, audit, or checker source:
```
uv run --script skills/html-d3-anime-video-workflow/scripts/build_from_prompt_contract.py --prompt ../prompt.md
```
  . The wrapper derives the report path, state checks, and Metro audits when the prompt contract calls for them. Verify with the compact wrapper report plus direct existence checks for required paths; read child audit manifests only when a wrapper or audit result fails.
Route component work to the existing skill that owns it:
- Use
```
d3
```
  for D3 visualization form selection, deterministic SVG geometry, labels, token colors, composition, and D3 gallery patterns.
- Use
```
slidev-animejs
```
  for Anime.js lifecycle, scoped selectors, cleanup, SVG helpers, text helpers, and Slidev click states.
- Use
```
slidev-video
```
  for Slidev deck recording, native navigation, MP4/WebM export, manifests, screenshots, and start trimming.
- Use
```
slidev-quality-audit
```
  for Slidev visual QA.
- Use
```
animated-svg-to-gif
```
  for GIF conversion from animated SVG assets.
- Use
```
manim-svg-video
```
  when the job is composing many existing SVG assets into a Manim-rendered MP4.
Use this skill only for the orchestration layer that those skills do not own: research-backed script refresh, multi-video planning, timestamp-driven HTML renderers, frame capture, ffmpeg encoding, repeated critique passes, manifests, and production notes.
When the user requests an artifact, write the exact requested output path. Do not substitute a descriptive filename, put the content only in chat, ask clarifying questions instead of acting, or write into the copied skill directory during isolated validation.
If the prompt supplies exact output paths plus enough source facts to start, proceed with conservative defaults for anything optional. Do not ask for duration, audience, style, narration, or format when the prompt already states them or gives a usable range. Record missing non-blocking facts as
```
null
```
,
```
missingFacts
```
, or production-note risks, then build the smallest valid source package, renderer, render script, video, and review artifacts requested.
For isolated complete-video requests where no project renderer exists yet, treat the bundled builders as executable tools, not files to inspect. When the prompt gives the exact wrapper command, run it exactly. When a prompt lists exact paths, source facts, and anchors but does not provide a full helper command, run
```
scripts/build_from_prompt_contract.py --prompt ../prompt.md --manifest <report.json>
```
to derive and run the standalone helper deterministically. If the prompt already names a
```
prompt-contract-build.json
```
report path, the wrapper can derive that manifest path when
```
--manifest
```
is omitted. If the prompt asks for Metro, design fidelity, complex dynamic visuals, low text, camera movement, colorset1, grayscale hierarchy, or says the result is not following the design, the wrapper derives a
```
metroPatternMix
```
from
```
scripts/plan_metro_pattern_mix.py
```
; when the scaffold pattern was
```
auto
```
, it applies the mix's
```
helperPattern
```
before deriving state checks. If the prompt names a
```
render-state
```
or
```
browser-state
```
JSON report path and no state flags are supplied, the wrapper can derive
```
--state-manifest
```
and default pattern, label-containment, final-state,
```
false->true
```
mechanism-reveal, and monotonic
```
visibleMechanismCount
```
progression checks from the selected scaffold pattern and preserved label headings. If the prompt names
```
metro-style-audit.json
```
,
```
metro-composition-audit.json
```
,
```
metro-rendered-frame-audit.json
```
,
```
metro-mute-test-audit.json
```
,
```
metro-video-composition-audit.json
```
, or
```
metro-audit-suite.json
```
, the wrapper can derive those audit paths, run the reusable Metro audit suite plus encoded-MP4 composition audit, and write the reports before exact-output verification. Add explicit
```
--state-manifest
```
,
```
--metro-style-manifest
```
,
```
--metro-composition-manifest
```
,
```
--metro-rendered-frame-manifest
```
,
```
--metro-mute-test-manifest
```
,
```
--metro-video-composition-manifest
```
,
```
--metro-audit-suite-manifest
```
,
```
--state-expect
```
,
```
--state-expect-final
```
,
```
--state-expect-contains
```
,
```
--state-expect-transition
```
,
```
--state-expect-monotonic
```
, and
```
--state-min-distinct
```
flags when the prompt asks for stricter proof in the same pass. For zone evidence, use
```
--state-expect-final visibleZoneCount=<count>
```
to prove the megacanvas exposes enough zones and use
```
--state-min-distinct activeZoneId=<count>
```
to prove the camera or beat path visits several zones; never add
```
--state-min-distinct visibleZoneCount
```
, because a stable visible zone count is expected. This prompt-contract wrapper path is the fast lane: do not read
```
visual-metaphor-design.md
```
,
```
scene-pattern-recipes.md
```
,
```
html-video-orchestration-patterns.md
```
,
```
metro-minimal-tonal-motion.md
```
,
```
visual-density-pattern-bank.md
```
, or
```
production-loop.md
```
before the wrapper run unless the prompt explicitly asks for bespoke design work. Read
```
references/standalone-helper-contract.md
```
only for manual fallback when the prompt lacks a wrapper command and the wrapper cannot derive a valid contract; in copied isolated workspaces use
```
skills/html-d3-anime-video-workflow/references/standalone-helper-contract.md
```
. Never open helper, wrapper, suite, audit, or checker source just to learn arguments or diagnose a passing run. The helper creates the source package, production notes, HTML with
```
renderConceptFrame
```
,
```
render.mjs
```
, draft MP4, metric contact sheet with JSON manifest, and self-review; the prompt-contract wrapper also writes a compact JSON derivation/build/media/source-preservation report when a manifest path is supplied or detected in the prompt, embeds
```
metroPatternMix
```
with selected density patterns, functional zones, semantic motion systems, camera path, transition contracts, and anti-pattern risks, embeds a compact
```
contactSheet
```
summary from the generated contact-sheet manifest with per-tile metrics plus
```
openingTile
```
,
```
finalTile
```
, and
```
openingTileAssessment
```
, adds a
```
weak-opening-tile
```
finding when the opening assessment is weak, and can embed compact
```
stateCheck
```
,
```
metroAuditSuite
```
,
```
metroStyleAudit
```
,
```
metroCompositionAudit
```
,
```
metroRenderedFrameAudit
```
,
```
metroMuteTestAudit
```
, and
```
metroVideoCompositionAudit
```
results when their manifest paths are supplied or derived. When the wrapper report and its embedded
```
contactSheet
```
summary both show
```
passed: true
```
, the generated contact-sheet manifest shows
```
passed: true
```
,
```
contactSheet.openingTileAssessment.weak
```
is
```
false
```
, any requested or derived
```
stateCheck.passed
```
is
```
true
```
, any requested
```
metroPatternMix.passed
```
is
```
true
```
, and any requested Metro audit reports including
```
metroVideoCompositionAudit
```
show
```
passed: true
```
, treat the requested scaffold outputs as validated, including prompt fact, anchor, and pattern label preservation from
```
sourcePreservation
```
plus MP4 duration, fps, width, and height from
```
media
```
; do not read child audit manifests or script sources unless a reported result fails. Passing these reports validates a scaffold, not a final polished design, when the prompt asks for Metro Minimal Tonal Motion, design fidelity, complex dynamic visuals, or low-text narrated output; after the wrapper run, load
```
references/metro-minimal-tonal-motion.md
```
and
```
references/visual-density-pattern-bank.md
```
before accepting or redesigning that artifact. If the wrapper fails only because a Metro child audit timed out or reported a transient browser failure, rerun the same wrapper command once before any diagnosis; if it still fails, report the manifest failure instead of reading helper, suite, audit, checker, HTML, or render source. If
```
contactSheet.openingTileAssessment.weak
```
is true or
```
contactSheet.openingTile
```
is much weaker than later tiles, improve the opening frame before accepting the draft even when aggregate metrics pass. If a Metro audit fails, regenerate from the source prompt with corrected helper inputs rather than patching generated HTML by hand. If you run extra diagnostics, write them to separate report paths and do not overwrite the requested MP4, contact sheet, or contact-sheet manifest. Edit or extend those outputs afterward only if the prompt requires richer visuals.
Apply the two production principles before writing scenes:
- Show mechanics visually. Express each concept through cause/effect motion, state changes, flows, ranking, accumulation, branching, blocking, or feedback loops.
- Default to zero visible explanatory text for narrated explainers. Assume narration carries names, definitions, and caveats; the video should carry diagrams, motion, and state changes.
- Graph only the concept. Do not add video duration, progress bars, chapter rails, timestamps, watermarks, status widgets, or decorative UI chrome unless those elements are the thing being explained.
- For tokenization scenes, render text as data-owned token groups from the first frame. Reveal a token group's own fill, border, numeric state, and destination instead of drawing boxes over an independent text node.
- For Metro Minimal Tonal Motion, strict-grid, or square-edge critiques, treat the design as a navigable modular megacanvas, not as a slide sequence. Build multiple functional zones that the camera explores through zooms, pans, expanding blocks, masks, or tile morphs; do not reserve title, subtitle, caption, or date bands inside the video frame. Use hard 0-radius rectangles, snapped 4 px grid edges, shared baselines, no internal box padding, the colorset1 Open Sans font stack, and distinct grayscale levels for visual hierarchy as the default visual contract. Do not leave latent rounded fallbacks such as
```
rx: masonryRequired ? 0 : 14
```
  in Metro sources; source-level nonzero
```
rx
```
  ,
```
ry
```
  , or radius branches are a design failure even if the current render path normalizes them. For polished Metro or "not following the design" repair work, require the source package to expose
```
visualZones
```
  and
```
semanticBindings
```
  , the SVG DOM to expose
```
data-zone-id
```
  ,
```
data-zone-role
```
  , and
```
data-source-anchor-json
```
  markers with legacy
```
data-source-anchor
```
  fallback, and
```
renderConceptFrame
```
  state to expose
```
visibleZoneCount
```
  , changing
```
activeZoneId
```
  , and
```
activeSourceAnchors
```
  . For helper-generated Masonry work, the encoded MP4 contact sheet must show the same low-text wall construction as the sampled HTML, with a non-weak opening tile and visible module growth rather than labels. Low-text Masonry is not just label suppression: selected helper marks must sit on a visible shared masonry megacanvas base, so the first frame already reads as an aligned modular wall instead of an isolated chart or panel.
- Do not abbreviate functional labels with
```
...
```
  or
```
…
```
  in final SVG output. If labels do not fit, recompute the layout, move labels to flush lanes, use smaller local type, or shorten source labels deliberately in the source package; visible truncation is a design failure.
Before choosing D3 examples, reusing previous scenes, or coding a beat, design the visual metaphor. Write the concept claim, the causal mechanic, two or three candidate metaphors, the rejected alternatives, the chosen visual vocabulary, and the exact repeated roles for shapes, colors, motion, and layout. Reuse an old visual pattern only when it preserves the same semantic role.
Read
```
references/visual-metaphor-design.md
```
when designing a new concept video, redesigning a weak beat, or responding to feedback that a scene feels generic, copied, decorative, or text-dependent.
Read
```
references/metro-minimal-tonal-motion.md
```
when the request mentions Metro Minimal Tonal Motion, colorset1, colorset2, strict-grid, hard edges, no rounded borders, no padding, grayscale hierarchy, Masonry, megacanvas, camera movement, or design feedback that the output is not aligned with the design.
- Use the bundled
```
references/metro-design-profile.json
```
  as the runtime palette and geometry source of truth. It records hashes of the source
```
style.md
```
  ,
```
colorset1.yml
```
  , and
```
colorset2.yaml
```
  ; do not replace it with a hand-written palette. Recompile it with
```
scripts/compile_metro_design_profile.py
```
  when those source files change.
- When the user says the video is not following the design, treat the current artifact as rejected. Recompose from the design contract before re-rendering: remove title/caption/date bands, remove padded boxes and rounded geometry, restore colorset1 gray hierarchy, prove modular alignment, and add camera or block-based transitions that preserve the megacanvas structure.
Read
```
references/visual-density-pattern-bank.md
```
when the request asks for more complex, dynamic, information-dense, visual rather than textual, pattern-based, or D3-influenced videos. Use it before accepting a scaffold that otherwise looks like boxes plus labels. For Metro redesign, run or inspect the wrapper's
```
metroPatternMix
```
from
```
scripts/plan_metro_pattern_mix.py
```
and require at least six named density patterns, three used beat patterns, five functional zones, four semantic motion systems, three camera events, three transition contracts, at least two transition types, one modular transition type such as tile morph, masked reframe, surface wipe, masonry construction, or expanding block, zero internal padding, 0-radius geometry, grayscale hierarchy, and
```
reusableD3PatternIds
```
when the mix maps to existing D3 patterns before accepting the design direction.

Treat named visual anchors from
```
design/videos.md
```
as render contracts. If a module names motifs such as
```
probability_bars
```
,
```
passN_grid
```
,
```
test_runner
```
, context-window shifts, judge/rubric cards,
```
agent_loop_ring
```
,
```
context_window_box
```
, fixed workflow versus adaptive agent lanes, environment changes, Model + Tools + State + Loop modules,
```
shield_gate
```
, Input/Output/Action gates, prompt bubble versus hard gate, Model Armor filter lanes,
```
risk_score
```
, human approval, protected
```
.env
```
/destructive/deploy actions, safety-versus-friction balance, policy matrix cues,
```
comparison_grid
```
, runtime stack, engine-to-dashboard morph, same model in different harness shells, three-column harness cards,
```
credit_meter
```
, feature grid versus use-case matrix, highlighted selection path,
```
event_timeline
```
, lifecycle event pulse, Hook
```
shield_gate
```
overlay, GitHub hook badges, Claude event cloud, OpenCode event list, PreToolUse command block, log-filter path, token-savings counter, speed-vs-cost slider, lifecycle-controls stamp, Atlassian Rovo, Gemini App, GitHub Copilot, Claude Desktop or Claude Code, workflow gravity, home-base workspace blocks, radar chart, use-case selector, guardrails, permissions, or observability wraps, those motifs must appear as visible low-text geometry in the final MP4 and contact sheet, not merely as preserved source strings in JSON.
For a multi-video source such as
```
design/videos.md
```
, run
```
scripts/plan_metro_video_series.py
```
before rendering the series. Do not accept one global
```
metroPatternMix
```
for the whole document as proof of design fidelity. Require the report to pass with per-module
```
helperPattern
```
,
```
primaryPattern
```
,
```
reusableD3PatternIds
```
, enough helper/primary diversity, and no long repeated-helper run, so distinct topics do not collapse into the same generic scaffold.
When a whole series is being regenerated after design-rejection feedback, generate prompt contracts with
```
scripts/build_metro_series_contract_prompts.py
```
before running
```
pi
```
. The generated prompts must include the wrapper command, render-state manifest, full Metro audit suite, encoded-MP4 composition audit, and semantic-density audit as exact required outputs. Use those generated prompts instead of hand-written per-video prompts so the batch cannot silently skip
```
metro-video-composition-audit.json
```
or the masonry/megacanvas repair contract.

Read
```
references/scene-pattern-recipes.md
```
when reusing an approved scene pattern, extracting a shared visual component, or preserving a good example from the current project. Treat the compact recipes as the runtime source of truth; inspect
```
assets/examples/
```
only when maintaining the acceptance fixture.
Before coding each beat, run a visual decision pass: identify the mechanism, the chosen shape metaphor, the visible data states, the elements omitted because narration carries them, and the existing D3/gallery/component example to adapt after the metaphor is chosen.
Define layout regions before drawing. Use explicit rows, columns, quadrants, shared baselines, and shared scale targets so related objects line up and keep consistent visual weight across a beat.
Split long videos into modules as soon as a block is approved or substantial: one orchestration entry point, shared data/palette/layout helpers, and separate files for beats or subscenes. Do not let one renderer file accumulate the full video.
When a user explicitly approves a video iteration, update this skill or the owning component skill with the transferable lesson before moving to the next beat.
Read
```
references/html-video-orchestration-patterns.md
```
when the request resembles a broader video workflow such as product/site source material, arbitrary text explainers, PR/code-change videos, short motion graphics, music-driven edits, captions, existing footage overlays, or multi-frame generated compositions.
Read
```
references/production-loop.md
```
before creating or improving a standalone HTML+D3+Anime.js video pipeline.
Read
```
references/routing.md
```
when the request overlaps another video, SVG, Slidev, D3, or Anime.js skill and the ownership boundary is unclear.
Keep one structured source of truth for video data: concepts, scenes, timings, references, metrics, color tokens, and output IDs.
Prefer deterministic timestamp rendering for final capture. Anime.js can enhance live preview, but final export should be reproducible from
```
renderFrame(conceptId, seconds)
```
.
For reusable browser capture, use
```
scripts/capture_html_video.py
```
against an HTML file that exposes
```
window.renderConceptFrame
```
. It serves the HTML over local HTTP, calls the deterministic frame function in Chromium for each timestamp, captures the requested selector, encodes frames with ffmpeg, and can assert returned render-state contracts such as
```
--expect-state visualPattern=systems-flow
```
,
```
--expect-state-final queueSlots=8
```
,
```
--expect-state-final retryVisible=true
```
,
```
--expect-state-transition retryVisible=false->true
```
,
```
--expect-state-final activeState=5
```
,
```
--expect-state-final atlasVisible=true
```
,
```
--expect-state-final activeRouteNodeCount=8
```
,
```
--expect-state-final lateClusterVisible=true
```
,
```
--expect-state-final rollbackVisible=true
```
,
```
--expect-state-final criteriaRevealed=4
```
,
```
--expect-state-final recommendationVisible=true
```
,
```
--expect-state-final interventionVisible=true
```
,
```
--expect-state-final activePhase=5
```
,
```
--expect-state-final anomalyVisible=true
```
,
```
--expect-state-final forecastVisible=true
```
,
```
--expect-state-final criticalPathVisible=true
```
,
```
--expect-state-final responseVisible=true
```
,
```
--expect-state-final fallbackVisible=true
```
,
```
--expect-state-final activeFlowCount=7
```
,
```
--expect-state-final outputVisible=true
```
,
```
--expect-state-final activeHandoffCount=8
```
,
```
--expect-state-final completeVisible=true
```
,
```
--expect-state-final activeThreatCount=4
```
,
```
--expect-state-final actionVisible=true
```
,
```
--expect-state-final activeScenarioCount=7
```
,
```
--expect-state-final outcomeVisible=true
```
,
```
--expect-state-final activeEvidenceCount=6
```
,
```
--expect-state-final confidenceVisible=true
```
,
```
--expect-state-final activeLayerCount=6
```
,
```
--expect-state-final rolloutVisible=true
```
,
```
--expect-state-final activeLineageCount=6
```
,
```
--expect-state-final rollbackVisible=true
```
,
```
--expect-state-monotonic visibleMechanismCount=nondecreasing
```
, and
```
--min-distinct-state visibleMechanismCount=4
```
. For a cheaper semantic gate before full encoding, run
```
scripts/check_html_render_state.py
```
against the same HTML; it samples
```
renderConceptFrame
```
in Chromium, writes a JSON state summary, and can assert pattern-specific state values without producing an MP4. For advanced systems, route-map, skill-tree-route, lifecycle, comparison, causal-loop, timeline, metric-dashboard, dependency-map, sequence-trace, sankey-flow, swimlane-handoff, risk-bowtie, scenario-tree, evidence-ladder, layered-architecture, or data-lineage videos, sample or capture the full mechanism duration at least once so branch, failure, feedback, queue fill, active state progress, route-node progress, damage/defense clusters, attribute bridge, keystone tradeoff, respec route, late specialization, keystone, Atlas, rollback, compensation, criteria reveal, score shift, recommendation, guardrail, loop, delay, damping, side-effect, intervention, active phase progress, handoff, anomaly, forecast, decision-window, dependency risk, bottleneck, cutover, latency budget, retry, fallback, response, split, loss branch, merge, active-flow count, final output, owner-lane handoff, SLA, rework, escalation, active-handoff count, completion, active-threat count, preventive barrier, top event, mitigative barrier, consequence, degraded barrier, repair action, active-scenario count, probability, upside, risk, decision gate, fallback, selected outcome, evidence tiers, counterevidence, source gap, confidence, uncertainty, recommendation timing, layer activation, cross-cutting policy, failure path, observability, rollout, lineage activation, transform rule, quality gate, drift monitor, consumer contract, or rollback route states are proven to transition from hidden to visible, not inferred from early-frame motion or static always-on flags.
For Harness Plugin videos, do not let
```
swimlane-handoff
```
fall back to rounded owner-lane cards. Use a hard-edge plugin-bundle megacanvas where
```
plugin_bundle_cube
```
, detachable modules, GitHub manifest, Claude marketplace allowlist, OpenCode npm/runtime drop, team install fanout, versioning/upgrade arrows, noisy-plugin cost risk, package install, and the packaged harness behavior stamp are state-checked visual mechanisms.
For Skill definition videos, do not let
```
systems-flow
```
fall back to queue, worker, retry, and dead-letter cards. Use a hard-edge skill-package megacanvas where
```
skill_card_stack
```
, the long prompt wall collapse, compatible
```
SKILL.md
```
folder structures, progressive disclosure cost meter, example skill cards, tool badges, script blocks, read-surface levels, bloated skill trimming, and the final on-demand reusable workflow stamp are state-checked visual mechanisms.
For AI alternatives videos, do not let
```
swimlane-handoff
```
fall back to owner-lane cards. Use a hard-edge AI-alternatives megacanvas where
```
comparison_grid
```
, Atlassian Rovo, Gemini App, GitHub Copilot, Claude Desktop or Claude Code home-base workspace blocks, a radar chart, use-case quadrants,
```
credit_meter
```
, workflow gravity selector, selected workflow path, guardrail/permission wraps, and observability wraps are state-checked visual mechanisms.
Render drafts quickly, but never treat low-frame-rate drafts as final. Use 6 fps only for iteration; use at least 30 fps for final delivery, and consider 60 fps for subtle motion.
Validate in layers: content schema, browser render-state smoke, draft render, automated MP4 review, visual contact-sheet critique, final render, final full review. For render-state gates, use
```
scripts/check_html_render_state.py
```
to verify exact labels, pattern identity, mechanism visibility, and state progression before paying for another video encode. For MP4 gates, use
```
scripts/review_video_quality.py
```
when a reusable report is needed; it checks expected duration, resolution, fps, file size, black spans, and freeze spans. For frame-level visual richness, use
```
scripts/audit_video_motion.py
```
; it samples frames and checks color diversity, nonbackground area, and changing frame pairs. For honest visual review sheets, use
```
scripts/make_video_contact_sheet.py
```
; it samples the encoded MP4, avoids exact-EOF frame misses, composes only real tiles, and can fail on low tile diversity, empty content, or repeated adjacent tiles. For exact output contracts, run the bundled checker at
```
uv run --script skills/html-d3-anime-video-workflow/scripts/check_video_outputs.py
```
in isolated workspaces, or the same skill-bundle-relative checker path in a repository checkout, with positional paths or
```
--require
```
,
```
--require-json-passed
```
,
```
--required-anchors
```
, and media expectations such as
```
--duration
```
,
```
--fps
```
,
```
--width
```
, and
```
--height
```
; do not probe root-level
```
scripts/
```
or open the checker source just to discover CLI arguments. If the prompt-contract wrapper already verified exact outputs and reports
```
passed: true
```
, do not run or inspect
```
check_video_outputs.py
```
again.
For Metro Minimal Tonal Motion or other color-restricted video requests, require the reusable
```
scripts/run_metro_audit_suite.py
```
runner, which invokes
```
scripts/audit_metro_tonal_style.py
```
,
```
scripts/audit_metro_composition.py
```
,
```
scripts/audit_metro_rendered_frames.py
```
, and
```
scripts/audit_metro_mute_test.py
```
, plus
```
scripts/audit_metro_video_composition.py
```
against the encoded MP4. Prefer naming
```
metro-style-audit.json
```
,
```
metro-composition-audit.json
```
,
```
metro-rendered-frame-audit.json
```
,
```
metro-mute-test-audit.json
```
,
```
metro-video-composition-audit.json
```
, and
```
metro-audit-suite.json
```
in the prompt or passing
```
--metro-style-manifest
```
,
```
--metro-composition-manifest
```
,
```
--metro-rendered-frame-manifest
```
,
```
--metro-mute-test-manifest
```
,
```
--metro-video-composition-manifest
```
, and
```
--metro-audit-suite-manifest
```
so the wrapper runs the full suite before exact-output verification; if only the suite manifest is supplied, the wrapper derives the four child report paths beside it and a sibling MP4 composition report. Do not open the suite or child audit source in normal video generation; their public contract is the wrapper flags and manifest fields. The tonal audit checks colorset1-only HTML color usage, absence of visible editorial
```
checked ... draft/scaffold
```
frame text, and source-package visual anchors. The composition audit checks 0-radius borders, hard line caps/joins, 4 px grid-aligned rectangle edges, shared-edge structure, runtime normalization for dynamic rectangles, zero box-padding/inset signals, and enough distinct grayscale levels to separate hierarchy in both the HTML source and the selected
```
visualPattern
```
branch from
```
source-package.json
```
, including a minimum luminance spread. The rendered-frame audit loads the generated HTML in Chromium, samples
```
renderConceptFrame
```
, then checks the live SVG DOM for 0-radius rects, hard line caps/joins, transformed/rendered 4 px grid-aligned rect edges, shared-edge composition, the declared zero-padding policy, measured zero-padding geometry for any
```
data-box-id
```
/
```
data-fill-for
```
fill associations, high-confidence untagged inset rectangles that look like internal padding,
```
data-zone-id
```
/
```
data-zone-role
```
functional-zone markers, area-weighted visible grayscale hierarchy levels, median active-sample gray hierarchy, active-sample pass ratio, final-frame grayscale hierarchy, text-area ratio, mark-to-text density, dominant text boxes, title/date/editorial text bands, required Masonry module count and size variety,
```
masonryModuleCounts
```
construction progression, nondecreasing module growth, low text-element/text-character counts for required Masonry, and red rectangle area for product-choice modules. The MP4 composition audit samples the encoded video and fails slide-like contact sheets with weak grid coverage, weak quadrant distribution, weak opening composition, weak distributed spatial progression, excessive text-like small-component pressure, or red-family pixel area above the configured threshold; it catches cases where DOM audits pass but the delivered video still reads as six labeled slides or broad red panels. The suite forwards a bounded four-sample mute test by default; because the mute-test still requires three hidden changing pairs, every adjacent hidden-text pair must change. The mute-test audit hides rendered SVG text and verifies that the remaining marks still show changing frame pairs, nonbackground area, functional zones, gray hierarchy, and enough visual marks, so the concept is not carried only by labels. Treat a failed audit as a style or composition failure before accepting the video.

Plan Artifact Tasks

When the task is to produce a Markdown plan, manifest, storyboard, production notes, or review file:

Read only the references needed for the requested source type and deliverable.
Write the requested file path in the workspace root or user-specified project directory before composing a final chat response.
Use the exact filename from the prompt, such as
```
production-plan.md
```
; do not rename it to
```
plan.md
```
,
```
implementation-plan.md
```
, or a project-specific default.
Preserve the user's source facts in the artifact. Include literal titles, identifiers, constants, event names, file names, durations, and named constraints from the prompt when they are part of the requested source package or plan.
Do not leave placeholders for facts the prompt already provides. A table cell like
```
_[exact title]_
```
is a validation failure when the title was supplied.
For PR/code-change plan artifacts, make the first section a filled
```
Source Facts
```
table copied from the prompt or source package. It must include exact PR title/summary, change size, behavior, filenames, constants, events, audience, style, and duration whenever supplied.
Verify the file exists, is non-empty, and contains the task's required literal anchors before final response.
Keep the final chat response brief and point to the created file.

Non-Duplication Rules

Do not copy D3 chart taxonomy, Anime.js API examples, Slidev recording options, or animated SVG conversion details into this skill. Link to the owning skill and load it when needed.
Store workflow lessons here only when they affect the cross-stack production process.
If a lesson is specific to D3 SVG extraction, Anime.js lifecycle, Slidev recording, or GIF encoding, update that owning skill instead of adding it here.

Pattern Promotion

When an approved scene, shared helper, render preset, storyboard gate, production loop, or validation routine proves reusable, update

references/scene-pattern-recipes.md

references/visual-metaphor-design.md

, or

references/production-loop.md

before finishing. If the pattern is component-local, update the owning component skill instead. Include trigger, visual metaphor, data/timing contract, implementation steps, validation command, and isolated-workspace caveats when relevant.

Validation

After changing this skill, run:

powershell

uv run --script scripts/validate-skills.py

For SkillOpt or SkillOpt-Sleep maintenance, use reviewed task files or exact

pi

prompts with required output paths and scoring commands. Do not auto-adopt mined session proposals unless the candidate passes the prompt-contract wrapper report plus the relevant Metro audits. A no-edit SkillOpt result with

baseline: 0

and

candidate: 0

means the harvested tasks lacked enough scoring signal for this skill, not that the skill is optimal; add or repair the task gate instead of weakening runtime instructions.

When changing standalone scaffold patterns, wrapper label extraction, source-preservation fields, or derived render-state defaults, also run:

powershell

uv run --script skills/html-d3-anime-video-workflow/scripts/check_standalone_pattern_contracts.py --output projects/<project-id>/artifacts/reviews/pattern-contract-check.json

When changing Metro tonal style handling, also run:

powershell

uv run --script skills/html-d3-anime-video-workflow/scripts/audit_metro_tonal_style.py --html projects/<project-id>/src/index.html --source-package projects/<project-id>/source/source-package.json --output projects/<project-id>/artifacts/reviews/metro-style-audit.json

When changing Metro composition or zero-padding handling, also run:

powershell

uv run --script skills/html-d3-anime-video-workflow/scripts/run_metro_audit_suite.py --html projects/<project-id>/src/index.html --source-package projects/<project-id>/source/source-package.json --style-output projects/<project-id>/artifacts/reviews/metro-style-audit.json --composition-output projects/<project-id>/artifacts/reviews/metro-composition-audit.json --rendered-frame-output projects/<project-id>/artifacts/reviews/metro-rendered-frame-audit.json --mute-test-output projects/<project-id>/artifacts/reviews/metro-mute-test-audit.json --output projects/<project-id>/artifacts/reviews/metro-audit-suite.json

When changing Metro audit behavior, also run:

powershell

uv run --script skills/html-d3-anime-video-workflow/scripts/validate_metro_audit_fixtures.py --output projects/<project-id>/artifacts/reviews/metro-audit-fixtures.json

When changing Metro design-contract references, storyboard prompts, or plan-output requirements, also run:

powershell

uv run --script skills/html-d3-anime-video-workflow/scripts/validate_metro_design_contract.py --plan projects/<project-id>/production-plan.md --contract projects/<project-id>/design-contract.json --output projects/<project-id>/metro-design-validation.json --require-text "<literal source anchor>"

When changing Metro semantic-density expectations, wrapper report summaries, state checks, contact-sheet metrics, encoded-MP4 composition metrics, camera-state requirements, or rendered adherence to

metroPatternMix

, also run:

powershell

uv run --script skills/html-d3-anime-video-workflow/scripts/audit_metro_semantic_density.py --wrapper-report projects/<project-id>/artifacts/reviews/prompt-contract-build.json --state-manifest projects/<project-id>/artifacts/reviews/render-state-check.json --contact-sheet-manifest projects/<project-id>/artifacts/video-renders/draft/review/<output-id>-contact-sheet.json --metro-audit-suite projects/<project-id>/artifacts/reviews/metro-audit-suite.json --metro-mute-test-audit projects/<project-id>/artifacts/reviews/metro-mute-test-audit.json --metro-video-composition-audit projects/<project-id>/artifacts/reviews/metro-video-composition-audit.json --output projects/<project-id>/artifacts/reviews/metro-semantic-density-audit.json

This semantic-density command requires the wrapper's

metroPatternMix

by default. It should fail when

selected.helperPattern

does not match the rendered

visualPattern

, when the pattern mix lacks enough zones, semantic motion systems, camera events, transition contracts, transition type variety, a modular transition type, a required Masonry pattern plus transition contract, anti-pattern risks, zero-padding contract, 0-radius contract, or grayscale hierarchy, when

source-package.json

lacks enough

visualZones

semanticBindings

, when source anchors are not bound to zones, mechanisms, rendered

data-source-anchor-json

data-source-anchor

markers, and render-state

activeSourceAnchors

, when render-state evidence lacks

visibleZoneCount

or changing

activeZoneId

, when ordered

statesSample

evidence lacks enough adjacent active-zone changes, camera-coupled zone changes, camera travel, or zoom depth, when rendered DOM evidence lacks enough zone markers to support the mix, when rendered text ends with three dots or a single-character ellipsis, when the MP4 composition audit shows slide-like grid/quadrant/progression weakness, or when the mute-test audit shows that hiding text removes the visual progression. Use JSON source-anchor attributes as the primary rendered evidence because Markdown tables and code snippets can contain

characters that break delimiter-based attributes. For required Masonry, it must also fail unless the rendered-frame audit proves real

data-masonry-module

geometry with enough modules, varied module sizes, enough occupied visual area, nondecreasing

masonryModuleCounts

with at least three distinct counts, enough count growth, low text-element/text-character counts, measured zero-padding coverage, and zero

paddedModuleInteriorViolationCount

. Treat

visibleZoneCount

as a presence/count signal and

activeZoneId

as the changing traversal signal.

When changing Metro pattern-mix selection, design-following gates, or low-text visual-density routing, also run:

powershell

uv run --script skills/html-d3-anime-video-workflow/scripts/plan_metro_pattern_mix.py --prompt-file design/videos.md --output projects/<project-id>/artifacts/reviews/metro-pattern-mix.json --require-anchor "LLM" --require-anchor "MCP" --require-anchor "agent"

When changing multi-video Metro planning or generating from a document with several

###

video modules, also run:

powershell

uv run --script skills/html-d3-anime-video-workflow/scripts/plan_metro_video_series.py --prompt-file design/videos.md --output projects/<project-id>/artifacts/reviews/metro-video-series-plan.json

Inspect

moduleCount

metrics.helperDiversity

metrics.primaryPatternDiversity

metrics.reusableD3PatternCount

metrics.maxSameHelperRun

helperSequence

, and each module's selected patterns before accepting a batch. A series report that fails for low diversity means the batch is still too generic even when individual Metro audits pass.

When changing design-repair series contracts, prompt generation, exact-output video batches, or Google Drive delivery prompts for a Metro series, also run:

powershell

uv run --script skills/html-d3-anime-video-workflow/scripts/build_metro_series_contract_prompts.py --source design/videos.md --output-dir projects/<project-id>/artifacts/prompts --project-root projects/<project-id>/videos --duration 6 --fps 6 --width 1280 --height 720 --limit 2

Inspect the generated manifest and prompt files. Each prompt should require

prompt-contract-build.json

render-state-check.json

metro-audit-suite.json

metro-video-composition-audit.json

, and

metro-semantic-density-audit.json

so a design-repair batch is validated from source package through encoded MP4.

When the source design or palette files change, refresh the self-contained runtime profile first:

powershell

uv run --script <skill-root>/scripts/compile_metro_design_profile.py --style design/style.md --colorset1 design/colorset1.yml --colorset2 design/colorset2.yaml --output <skill-root>/references/metro-design-profile.json
uv run --script skills/html-d3-anime-video-workflow/scripts/validate_metro_design_profile.py --style design/style.md --colorset1 design/colorset1.yml --colorset2 design/colorset2.yaml --output projects/<project-id>/artifacts/reviews/metro-design-profile-validation.json

The profile must pass and its digest must appear in generated series prompts and tonal-audit reports.

--allow-colorset2

is valid only with a non-empty

--colorset2-reason

; it still permits only colors declared by the compiled colorset2 source.

When changing standalone scaffold geometry, gray hierarchy, zero-padding normalization, or selected-pattern rendering, also run the no-video cross-pattern smoke:

powershell

uv run --script skills/html-d3-anime-video-workflow/scripts/validate_metro_pattern_smoke.py --output projects/<project-id>/artifacts/reviews/metro-pattern-smoke.json --workdir projects/<project-id>/artifacts/reviews/metro-pattern-smoke-work --no-install-browser --timeout-seconds 180

For design-rejection, low-text, or Masonry changes, add

--masonry-layout

to this smoke command. Inspect the report's top-level

aggregateMetrics

maxRenderedInternalPaddingPx

, total padding/inset violation counts,

minMedianGrayLevelCount

minFinalGrayLevelCount

patternsWithWeakGrayHierarchy

minMaxMasonryModuleCount

minMaxMasonrySizeCount

minMasonryModuleCountDistinct

maxMasonryTextElementCount

, and

patternsWithWeakMasonry

should all support the no-padding, grayscale-hierarchy, modular-composition, and low-text claims. For product-choice modules such as AI alternatives, also inspect

metro-rendered-frame-audit.json

for

maxRedRectAreaRatio

; broad red rectangles are a design failure even when alignment, padding, and text metrics pass.

When changing a referenced example pipeline, also run its content validator, a browser smoke test, one representative render, and the final MP4 review script for the affected output set.

html-d3-anime-video-workflow

NPX Install

Tags

SKILL.md Content

HTML D3 Anime Video Workflow

Core Workflow

Plan Artifact Tasks

Non-Duplication Rules

Pattern Promotion

Validation