asset-license-checker

name	asset-license-checker
description	Verify license compliance for downloaded 3D assets, textures, HDRIs, fonts before scene build or export.

asset-license-checker

Purpose

Catch license risk before assets go into a scene that will be rendered, exported, or shipped. This is a planning / validation skill — does not modify assets, does not consult lawyers.

Quick start

• list every external asset (model, texture, HDRI, font, sound, brushes)
• record source URL + license name + permissions per asset
• flag risk per asset (Pass / Warn / Fail)
• emit asset row table + handoff to scene build only if all rows are Pass or explicitly accepted Warn

When to use

• after blender-asset-discovery-planner produces asset list
• before scene build / mutation / render
• before any export or commercial distribution
• when a previously-used asset's license is unclear

When not to use

• asset modeling that you author yourself (no third-party license)
• pure planning before assets are sourced
• legal advice (this skill flags risk; it does not give legal opinion)

Trigger phrases

• "is this license OK"
• "can I use this commercially"
• "what's the license"
• "license check"

Prerequisites / readiness

• asset list with sources known
• intended use case known (commercial / non-commercial / internal / open-source)
• target license compatibility known (e.g., MIT / CC0 / CC-BY / proprietary)

Input schema

Required inputs

Input	Why it is required
Asset list (name + source)	Scope of check
Intended use case	Drives compatibility
Target attribution policy	Some licenses require attribution

Optional inputs

Input	Use
Existing internal license whitelist	Pre-approved sources
Brand legal policy	Per-company override rules

Assumptions to confirm

• Asset license file or page is publicly readable.
• License version is current (licenses sometimes change).
• The user's intended use is accurately stated.

Output schema

Primary output

A per-asset row table: name, source URL, license name, attribution required (Y/N), commercial allowed (Y/N), modification allowed (Y/N), redistribution allowed (Y/N), verdict (Pass / Warn / Fail), notes.

Secondary output

• attribution lines required (if any)
• assets to remove if Fail
• top-line status

Evidence / caveat output

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

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

Validation skill — does not modify assets, does not run Blender. Verdicts are based on documented license terms, not legal interpretation. Not legal advice: when in doubt, recommend the user consult their legal team.

Operating procedure

1. Read asset list from blender-asset-discovery-planner output.
2. For each asset, look up its license (per references/license-source-rules.md).
3. Map license to permissions (commercial / modification / redistribution / attribution).
4. Compare against intended use.
5. Assign verdict per asset.
6. List required attribution lines.
7. Flag assets to remove if Fail.
8. Hand off to scene build only if all Pass / explicitly accepted Warn.

Decision tree

License unknown?
  → Fail until source confirmed
"Free for personal use" but commercial intent?
  → Fail
"Free for any use, attribution required" + intended attribution policy = "no attribution"?
  → Fail
"CC0 / public domain"?
  → Pass for any use
"Proprietary / EULA"?
  → Read EULA carefully; default Warn until terms clarified

Playbooks

Playbook A: Commercial brand campaign

Strict policy: only CC0, MIT, or paid-licensed assets. CC-BY allowed if attribution renders correctly. No CC-BY-NC.

Playbook B: Internal tool / non-commercial

Most CC variants allowed; flag attribution requirements; track them.

Playbook C: Open-source pack release

Match the pack's license; for MIT pack, only MIT or more-permissive (CC0) assets.

Mode handling

Text-only mode

License rows from asset spec; no actual file inspection.

Runtime-ready mode

License rows verified from actual asset metadata where available.

Blocked runtime mode

Skip rows that need file inspection; mark as such.

Validation checklist

• Every asset has a row
• Source URL recorded
• License name recorded
• Permissions per row recorded (commercial / modification / redistribution / attribution)
• Verdict assigned
• Attribution lines listed
• Top-line status derived

Pass / Warn / Fail rubric

Verdict	Criteria
Pass	License explicit + permissions match intended use + attribution handled.
Warn	License clear but attribution policy needs verification, or "all rights reserved" with no clear permission.
Fail	License missing / contradicts intended use; commercial use of non-commercial license; redistribution requested but not allowed.

Failure handling

• License unknown → block asset until clarified.
• Attribution required but no plan to render attribution → block until plan exists.
• "Probably fine" answer → downgrade to Warn; user must accept.

Troubleshooting

Problem	Response
License page 404	Block asset; require alternative source.
License changed since download	Re-evaluate; assets purchased at older terms usually grandfather, but verify.
Mixed-license aggregation (asset bundle with multiple licenses)	Treat each sub-asset separately.
AI-generated asset	Verify the AI tool's license terms permit your use case.

Best practices

• Record license at acquisition time, not at build time.
• Maintain an internal whitelist for repeat sources.
• Never ship without verifying every external asset's license.
• "Not legal advice" — escalate ambiguity to legal.

Good examples

• "Asset: hdri-studio.exr, source: polyhaven.com, license: CC0, commercial: Y, attribution: N (CC0). Verdict: Pass."

Bad examples

• "Asset is from internet." — no source, no license.

User-facing response template

Intended use: <commercial / non-commercial / internal / open-source>
Attribution policy: <where attribution will render or "none">

| Asset | Source | License | Comm | Mod | Redist | Attribution | Verdict | Notes |
|---|---|---|---|---|---|---|---|---|

Required attribution lines:
  - <line 1>
  - <line 2>

Assets to remove (Fail): <list or "none">
Top-line: <Pass / Warn / Fail>
Note: not legal advice; escalate ambiguity to legal team.
Limitations: <gaps>
Next: scene build (only if Pass) / asset re-discovery (if Fail)

Anti-patterns

• "Should be fine" verdicts.
• Skipping the attribution plan.
• Treating "all rights reserved" assets as usable.
• Inventing license terms.

Cross-skill handoff

• Asset discovery → ../blender-asset-discovery-planner/SKILL.md
• Style consistency → ../asset-style-consistency-checker/SKILL.md
• Fallback strategy → ../asset-fallback-strategy/SKILL.md
• Library organization → ../asset-library-organization-planner/SKILL.md

Non-goals

• Give legal advice.
• Modify asset files.
• Run Blender.
• Negotiate licenses.

References

• references/common-license-mapping.md
• references/license-source-rules.md
• references/attribution-rendering-patterns.md
• ../../docs/skill-system.md