color-management-decision

Purpose

Avoid the most common Blender color mistake: rendering with the wrong color space and then "fixing" it in post. Pick the color management strategy upfront based on the consumer's color pipeline.

Quick start

• Identify the consumer pipeline (web sRGB / film/VFX ACES linear / game engine / print / GLB-Three.js).
• Pin the 4-line render color config: Display Device, View Transform, Look, and Sequencer.
• Define per-output color transforms if multiple outputs exist.
• Emit the 4-line config record, caveats, truth states (Not Run / Not Produced), and handoff.

When to use

• before render / lookdev pass
• when consumer color pipeline is known
• when a previous render had unexpected color shifts

When not to use

• Post-render color grading or soft-proofing (handled by compositor / DCC after render). → use ../output-format-decision/SKILL.md (Delegates out-of-scope requests to output-format-decision)
• Validating per-material texture color spaces such as sRGB vs Non-Color/Linear (material-quality-checker). → use ../material-quality-checker/SKILL.md (Delegates out-of-scope requests to material-quality-checker)
• Selecting file formats or bit depths (output-format-decision). → use ../output-format-decision/SKILL.md (Delegates out-of-scope requests to output-format-decision)
• Choosing the render engine (cycles-vs-eevee-decision). → use ../cycles-vs-eevee-decision/SKILL.md (Delegates out-of-scope requests to cycles-vs-eevee-decision)
• Monitor hardware calibration (out of scope). → use ../material-quality-checker/SKILL.md (Delegates out-of-scope requests to material-quality-checker)
• Raw modeling without lookdev (color management does not affect geometry accuracy). → use ../cycles-vs-eevee-decision/SKILL.md (Delegates out-of-scope requests to cycles-vs-eevee-decision)

Trigger phrases

• "what color space"
• "Filmic vs Standard"
• "ACEScg for our pipeline"
• "colors look weird"

Prerequisites / readiness

• Consumer pipeline known (web sRGB, film/VFX ACES linear, game engine, print, or GLB-Three.js).
• Target output list known (or handed off from output-format-decision).

Input schema

Required inputs

Optional inputs

Assumptions to confirm

• The user knows the consumer pipeline (or is willing to confirm it before pinning).
• "Just looks good" is not a valid target; explicit consumer pipeline match is required.

Output schema

Primary output

A 4-line config record: Display Device, View Transform, Look, Sequencer.

Secondary output

• Per-output color transform rules when multiple outputs are planned
• Caveats per choice
• Truth-state and evidence block

Evidence / caveat output

Runtime status: Not Run | Attempted | Produced | Verified | Failed
Artifact status: Not Produced | Produced | Verified | Failed
Evidence used: <links, paths, logs, or "none">
Limitations: <known gaps>

Rules:

• Default Artifact status is Not Produced.
• Truth states are downgrade-only, never upgrade.
• Pinning a color config never produces a render (Runtime status: Not Run, Artifact status: Not Produced).

Required laws

• ../../laws/evidence-before-done.md
• ../../laws/non-blender-user-language.md
• ../../laws/no-arbitrary-python-interface.md
• ../../laws/official-runtime-only.md

Official runtime boundary

Decision skill — does not run Blender. Pins config; operator applies in scene render properties.

Operating procedure

1. Identify the consumer pipeline (web sRGB, film/VFX ACES linear, game engine, print, or GLB-Three.js).
2. Map the pipeline to the 4-line scene render color config (see references/pipeline-mapping.md).
3. Pin Display Device, View Transform, Look, and Sequencer.
4. Document per-output color transforms if multiple outputs are required.
5. List pipeline caveats and delegate adjacent scopes (material-quality-checker for material texture spaces, output-format-decision for file formats, cycles-vs-eevee-decision for engine choice, glb-web-handoff for GLB web delivery, render-export-evidence for post-render verification).

Decision tree

Web (sRGB)?
  -> Display Device: sRGB | View Transform: Filmic or AgX (Standard for flat unlit color) | Look: None | Sequencer: sRGB
Film / VFX with ACES (linear)?
  -> Display Device: sRGB | View Transform: AgX or Filmic (for viewport preview) | Look: None | Sequencer: sRGB | Per-output transform: scene-linear for linear handover (file format owned by output-format-decision)
Game engine?
  -> Display Device: sRGB | View Transform: Standard | Look: None | Sequencer: sRGB | Hand off per-material texture color-space validation to material-quality-checker
Print?
  -> Display Device: sRGB | View Transform: Filmic or AgX | Look: None | Sequencer: sRGB | Caveat: CMYK conversion/soft-proofing belongs to external print prep / DCC outside this skill
GLB-Three.js?
  -> Display Device: sRGB | View Transform: Filmic or AgX | Look: None | Sequencer: sRGB | Caveat: match with Three.js outputColorSpace via glb-web-handoff; delegate texture space checks to material-quality-checker

Playbooks

Playbook A: Web hero (web sRGB)

• Display Device: sRGB
• View Transform: Filmic (or AgX)
• Look: None (or Medium High Contrast if requested)
• Sequencer: sRGB
• Per-output transform: Bake display/view transform into display-referred web output (format owned by output-format-decision).

Playbook B: Film / VFX ACES linear

• Display Device: sRGB
• View Transform: AgX
• Look: None
• Sequencer: sRGB
• Per-output transform: Preserve scene-linear data without baked view transform for VFX turnover (format owned by output-format-decision).

Playbook C: Game engine

• Display Device: sRGB
• View Transform: Standard
• Look: None
• Sequencer: sRGB
• Per-output transform: Keep ungraded display transform; hand off per-material texture color-space checks to material-quality-checker.

Playbook D: GLB-Three.js

• Display Device: sRGB
• View Transform: Filmic (or AgX)
• Look: None
• Sequencer: sRGB
• Per-output transform: Align Blender viewport lookdev transform with target Three.js outputColorSpace = SRGBColorSpace via glb-web-handoff; hand off material texture color-space validation to material-quality-checker.

Mode handling

Text-only mode

Emit the 4-line config record, per-output transforms, caveats, and truth states (Runtime status: Not Run, Artifact status: Not Produced).

Runtime-ready mode

Emit the 4-line config record, per-output transforms, and caveats for the operator to apply in Blender scene render properties. Because this skill never runs Blender and pinning a config never produces a render, keep Runtime status: Not Run and Artifact status: Not Produced until render-export-evidence evaluates actual output.

Blocked runtime mode

Emit the 4-line config record, per-output transforms, caveats, and truth states (Runtime status: Not Run, Artifact status: Not Produced).

Validation checklist

• Consumer pipeline identified (web sRGB, film/VFX ACES linear, game engine, print, or GLB-Three.js)
• All 4 lines pinned (Display Device, View Transform, Look, Sequencer)
• Per-output color transform rules specified when multiple outputs exist
• Caveats listed and no subjective "looks good" verdict used
• Truth states set to Runtime status: Not Run and Artifact status: Not Produced (downgrade-only; pinning never produces a render)
• No role blur into per-material texture spaces (material-quality-checker), file formats (output-format-decision), engine choice (cycles-vs-eevee-decision), post-render grading, or monitor calibration

Pass / Warn / Fail rubric

Failure handling

• Pipeline unknown: ask once; if still unspecified, state assumption and default to web sRGB (Display Device: sRGB, View Transform: Filmic, Look: None, Sequencer: sRGB).
• Mixed pipelines from the same scene (e.g., web sRGB preview + film/VFX ACES linear turnover): specify distinct per-output color transform rules so the operator applies each transform per output pass without mixing baked and scene-linear color spaces.

Troubleshooting

Best practices

• One config per render, not "default and hope".
• Verify with a known reference (color chart or brand color).
• Document choices in scene metadata.
• Avoid post-process color grading inside Blender for web — let the consumer do it.

Good examples

• "Consumer pipeline: web sRGB. Display Device: sRGB. View Transform: Filmic. Look: None. Sequencer: sRGB. Per-output rule: apply display/view transform to web delivery output (file format pinned via output-format-decision). Runtime status: Not Run. Artifact status: Not Produced."

Bad examples

• "Use Filmic." — no pipeline context.

User-facing response template

Consumer pipeline: <web sRGB | film/VFX ACES linear | game engine | print | GLB-Three.js>
Output(s): <list>

Color management config:
  Display Device: <…>
  View Transform: <…>
  Look: <…>
  Sequencer: <…>

Per-output rules:
  <output>: <per-output color transform rule>

Caveats: <list>
Runtime status: Not Run | Attempted | Produced | Verified | Failed
Artifact status: Not Produced | Produced | Verified | Failed
Evidence used: <links, paths, logs, or "none">
Limitations: <known gaps>
Next: <render-export-evidence | material-quality-checker | output-format-decision | cycles-vs-eevee-decision | glb-web-handoff>

Anti-patterns

• Saying "Just use Filmic" without identifying the consumer pipeline.
• Claiming Produced or Verified artifact/runtime status when only pinning a color config.
• Auditing per-material texture nodes here instead of handing off to material-quality-checker.
• Prescribing file containers/codecs here instead of handing off to output-format-decision.
• Doing post-render color grading inside the scene color-management decision step.

Cross-skill handoff

• [progression] Output format selection → ../output-format-decision/SKILL.md
• [progression] Material texture color spaces → ../material-quality-checker/SKILL.md
• [progression] Render engine choice → ../cycles-vs-eevee-decision/SKILL.md
• [progression] GLB Three.js delivery → ../glb-web-handoff/SKILL.md
• [progression] Render evidence verification → ../render-export-evidence/SKILL.md

Non-goals

• Validate per-material texture color spaces (material-quality-checker).
• Choose output file formats or bit depths (output-format-decision).
• Choose the render engine (cycles-vs-eevee-decision).
• Perform post-render color grading (belongs to compositor / DCC).
• Calibrate a physical monitor (out of scope).
• Run Blender or execute renders.

References

• references/pipeline-mapping.md
• references/per-channel-rules.md
• references/look-comparison.md
• ../../docs/skill-system.md