# blender-pipeline

Adopt this skill: https://proskills.md/skills/other/freedomintelligence-blenderlore-skills-blender-pipeline

Page: https://proskills.md/skills/other/freedomintelligence-blenderlore-skills-blender-pipeline
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/blender-pipeline/editing/SKILL.md
size: 6172
sha: b76259d09cfdf6c475624606be8dcd7b69ba6a69
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/SKILL.md

````text
---
name: blender-existing-asset-editing
description: Edit a declared part of an existing Blender project while preserving its authored composition, verifying non-target stability, and producing a reopen-verified receipt. Use for material, color, geometry, modeling, or scene edits; use a generation workflow when the whole asset must be created from zero.
---

# Blender Existing-Asset Editing

Use this workflow when the source is an existing `.blend` project and only a declared scope should change. The source project does not need to have been produced by a generation pipeline. Any replacement asset introduced by the edit must come from the authorized generation process or from declarative geometry in the reviewed request; this package never executes arbitrary request code.

## Runtime boundary

Install the ordinary Python package from this directory:

```bash
python -m pip install -e '.[test]'
python -m unittest discover -s tests -v
```

`bpy` is deliberately not a pip dependency. Run project inspection and mutation with the Python bundled in Blender. Pass every source, request, and output path explicitly; do not put workstation or server paths into code or receipts.

## Required workflow

1. Create an edit request conforming to `schemas/edit_request.schema.json`. Bind it to the exact source file SHA-256 and name every target.
2. Run preflight before mutation. Reject a source hash mismatch, absent targets, linked read-only targets, missing external dependencies, or a request that overlaps its output.
3. Capture a deterministic source snapshot. Apply exactly one edit kind: `material`, `color`, `geometry`, `modeling`, or `scene`.
4. Preserve authored structure outside the declared scope. Material edits retain the node tree and change only declared materials. Geometry edits retain object identity, transforms, collections, and material slots. Modeling may add only explicitly named generated objects or approved modifiers. Scene edits touch only declared lights, camera, world, or exposure fields. Snapshots expose constraints, drivers, NLA, compositor state, and important render/color settings so undeclared drift fails closed.
5. Geometry may use declarative vertices/faces or a generation handoff. A handoff must bind an accepted GEN-V3 attempt receipt by file SHA and receipt self-hash, bind the receipt's exact `asset.blend` by SHA/size, and name one mesh object. The evaluated donor mesh is fitted into the target envelope while the target object and its material slots remain authoritative. Compare the target's evaluated visible world mesh before and after at the evidence frame; record and verify transform/orientation, world envelope center, per-axis envelope ratios, and bounding-box volume ratio. Geometry targets with shape keys, animation/drivers/NLA, constraints, armature or simulation dependencies, instancing, or mismatched viewport/render modifier settings are outside this single-frame review contract and fail closed.
6. Run `prepare`: render before, apply, pack, validate non-target drift, save and reopen `candidate.blend`, render after with the same camera/settings, and atomically publish an `awaiting_review` package. Structural success is not completion.
7. Obtain an external human or VLM assessment conforming to `schemas/assessment.schema.json`. It must bind `review_package.json`, `candidate.blend`, `before.png`, and `after.png` by SHA-256, score both versions, keep `after >= before`, and meet the request threshold (at least 80).
8. Run `finalize`: verify every binding, reopen the assessed candidate, match its saved snapshot, then atomically publish `asset.blend`, evidence, assessment, and a non-null-visual `complete` receipt. A failed or unreviewed run must not publish a completed result.

Do not clear a material node tree to perform a local edit. Do not silently resize a replacement: geometry replacement is fitted to the source local bounding box by default and checked against declared envelope, volume-ratio, and world-center tolerances. Inline replacements must rebuild every source UV layer; generation handoffs must retain those layer names. Unsupported shape keys or color attributes fail preflight instead of being discarded. Visual evidence and external review are mandatory for completion; `evidence.render=false` is invalid.

## Commands

Validate a request outside Blender:

```bash
python -m blender_edit_pipeline.pipeline validate-request --request edit.json
```

Preflight, prepare, and finalize inside Blender (arguments after `--` belong to the pipeline):

```bash
blender source.blend --background --python src/blender_edit_pipeline/pipeline.py -- preflight --request edit.json --output source_map.json
blender source.blend --background --python src/blender_edit_pipeline/pipeline.py -- prepare --request edit.json --review-dir review
blender --background --python src/blender_edit_pipeline/pipeline.py -- finalize --review-dir review --assessment assessment.json --output-dir edited
```

`apply --output-dir review` remains a compatibility alias for `prepare`; it produces `awaiting_review`, never `complete`. Use `--overwrite` only when replacement of an existing review or completed output was explicitly authorized. The implementation keeps a backup until the new directory is in place.

## Request modes

- `material`: set declared Principled-BSDF inputs without destroying the graph.
- `color`: set Base Color or insert a Hue/Saturation node at the declared material input.
- `geometry`: replace mesh data from declared vertices/faces or one SHA-bound accepted generation attempt, retaining target identity, material slots, transform, and fitted envelope.
- `modeling`: add allowlisted primitives or modifiers declared in the request.
- `scene`: edit declared lights, a declared camera, world color, or exposure only when those scopes are explicitly enabled.

Treat an edit as complete only when `finalize` emits `status: "complete"`, `visual_evidence` contains the bound external assessment with non-regressing scores, `non_target_drift` is empty, `reopen.verified` is true, and every published artifact hash matches. An `awaiting_review` package is deliberately incomplete.
````

## File: skills/blender-pipeline/generation/SKILL.md
size: 6655
sha: 0060713a8cfb9348aa3789dda95d3846a2bab9e0
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/SKILL.md

```text
---
name: blender-pipeline-generation
description: Generate an editable Blender asset or animation from a blank scene, either by replaying verified tutorial-video evidence or by executing a model-direct generation task. Use for from-zero reconstruction; use the edit pipeline when an existing scene or asset must be modified.
---

# Blender Generation Pipeline

Produce an editable `.blend` as the primary artifact. Treat preview renders,
six-view images, turntables, receipts, and traces as validation evidence rather
than substitutes for the scene.

## Choose a route

- Use tutorial replay when a video or tutorial is the source of truth. Prepare
  timestamped evidence, retrieve relevant knowledge, generate the scene, then
  compare it with the verified visual references.
- Use model-direct generation when a structured task and reference preview are
  already available. Begin from a canonical blank scene and run the bounded
  harness in `scripts/model_direct_generation_v3_harness.py`.
- Do not use either route to edit an existing asset. Route that work to the
  sibling edit pipeline.

## Configure the environment

Install `requirements.txt`; add `requirements-knowledge.txt` only when building
or querying the semantic knowledge index. Blender supplies `bpy`, `mathutils`,
and `bpy_extras`; never install those modules with pip. Install Blender and
FFmpeg separately. OCR evidence additionally uses the optional `tesseract`
executable.

Paths default below this skill's `output/` directory. Override them with
`VIDEO2BLENDER_OUTPUT_ROOT` and `BLENDER_VIDEO_ROOT`. Set `BLENDER_PIPELINE_BLENDER` to the Blender
executable. Paid model calls require an owner-only secret file via
`BLENDER_PIPELINE_API_KEY_FILE` and an explicit HTTPS endpoint via
`BLENDER_PIPELINE_API_ENDPOINT` and `VIDEO_REPLAY_APPROVED_PAID_API_ENDPOINT`. Do not
commit credentials, provider endpoints, machine mounts, or recovery authority
files. Deprecated `PAPER12_*` options are accepted as lower-priority aliases;
new integrations must use the `BLENDER_PIPELINE_*` prefix.

## Replay verified tutorial evidence

Ordinary users should start with repository-root `run_api.py` or `run_codex.py`.
These prepare one isolated workspace, default to a local manifest-only knowledge
index, and invoke the following maintained stages. `codex-cli` supplies both
tutorial extraction and downstream code-generation/visual-review calls without
an API key. The low-level commands below are for existing prepared workspaces.

1. Put the source video and any transcript under one `video-dir`.
2. Read the sibling [tutorial extraction skill](../tutorial-extraction/SKILL.md)
   and run its canonical `extract_video_tutorial.py` entrypoint. It performs
   the selected workflow. `--tutorial-method visual` uses the
   `video-to-visual-tutorial` workflow: coarse contact sheets, focused
   frame inspection, a compact evidence ledger, and a complete learner-facing
   procedure. Run the entrypoint with `--workspace-mode` to adapt that package
   to the existing replay files. Pass actual learner assets with repeatable
   `--input-asset`; do not classify the source video or acceptance preview as
   a learner asset. `--tutorial-method legacy-rich` uses the original complete
   60-second rich windows and base64 Markdown through the same canonical
   entrypoint. Do not call those compatibility helpers as a competing public
   launcher. The visual method is recommended for videos up to ten minutes.
   Run `build_pipeline_specs.py` after extraction.
   `tutorial.md` and its derived `steps_verified.json` preserve the operational
   contract. The separate rubric is never supplied as task instructions.
   Add `--render-html` on the extractor (or `--render-tutorial-html` on the
   low-level replay orchestrator) only when a separate human-readable
   HTML view is useful; it is rendered from the same complete Markdown and never
   replaces the operational files.
3. Run `run_video_replay_main.py --video-dir <dir>`. The orchestrator invokes
   the strict replay, version registry, render evidence, and candidate
   knowledge update stages.
4. Require an editable scene, a successful fresh render, complete six-view
   evidence, and a turntable or validated animation delivery when motion is
   actually supported by evidence.

Tutorial text and timestamped frames outrank titles and stylistic hints. Never
invent motion merely because a requested route says “dynamic”; downgrade to a
static result unless subject animation is proved by keyframes, Actions/NLA,
shape keys, time-dependent materials, simulations, or equivalent runtime
evidence. Preserve the demonstrated asset family, silhouette, detail density,
camera framing, lighting, and material response.

Two legacy route labels remain in receipts for compatibility. `RW1` means
source-project replay: preserve authored scene content and real subject motion,
using bounded replacement framing only when the authored camera is unusable.
`RW2` means a multi-part tutorial-series reconstruction: the tutorial and
verified steps are authoritative, and unrelated title-card or editor tail
frames must not become final visual references. Neither label denotes the
existing-asset edit pipeline.

## Run model-direct generation

Use `model_direct_generation_v3_harness.py create-blank` to establish the
canonical blank scene, then validate the exact-50 release task index.
`run-task` selects one item from that release index. The current `run-batch`
command rejects any other batch size and must not be presented as a general
batch runner. Supply explicit call and token budgets. Generated `generate.py`
must be self-contained Blender code: the contract rejects filesystem escape,
network access, subprocesses, dynamic imports, external project loading, and
private provenance. Each attempt is immutable and must reopen the saved blend,
render fresh evidence, and pass both the generation rubric and visual judge.

## Knowledge lifecycle

Build a portable manifest with
`build_blender_knowledge_index.py --manifest-only`; install the optional
knowledge dependencies to build Qdrant. Retrieve with
`retrieve_blender_knowledge.py --video-dir <dir>`. New replay observations are
successful candidate knowledge only and remain outside active retrieval.
Admission requires five independent human-reviewed accepted assets, a disjoint
human-reviewed accepted holdout with zero regression, artifact hashes, and
explicit route/family/Blender-version scope. Failed runs are diagnostics, never
active lessons. Production evidence is ingested only through an explicit,
bounded `--external-manifest`; the builder never crawls local run outputs.
```

## File: skills/blender-pipeline/reproduction/SKILL.md
size: 2614
sha: 3f24ec65d6259c47a7c427dd94814e08dbae5f40
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/SKILL.md

```text
---
name: blender-pipeline-reproduction
description: Reproduce a maintained Blender showcase recipe from authorized video, tutorial, image, or local asset inputs while enforcing visual-acceptance and asset-distribution gates.
---

# Blender Showcase Reproduction

Use `scripts/reproduce.sh` to select one exact recipe. The command is a dry run
unless the user explicitly authorizes `--execute`.

The packaged public catalog is metadata-only. It records the current public
showcase identity, input bindings, dynamic acceptance contracts, known gaps,
and distribution policy; it contains no source assets or tutorial media. A
public preview URL is acceptance evidence, not permission to download or reuse
the asset. A recipe that is disabled, blocked, incomplete, or not independently
accepted must fail before download, model invocation, or Blender execution.

## Tutorial inputs

- For an authorized existing tutorial, use `--tutorial-mode provided` and one
  or more `--tutorial` files. The operational truth is `tutorial.md` plus
  `steps_verified.json`.
- To extract an operational tutorial from video, explicitly use
  `--tutorial-mode extract`, `--video-url`, at least one `--image`, and a
  positive `--tutorial-window-budget`. Extraction delegates to the sibling
  [tutorial extraction skill](../tutorial-extraction/SKILL.md), defaults to the
  balanced profile and `gpt-5.6-sol`. The supplied `video-to-visual-tutorial`
  skill produces a complete procedure; a compatibility adapter supplies the
  existing replay files. `gpt-5.5` is an explicit whole-run fallback only and
  requires `--tutorial-fallback-reason`.
- Paid extraction requires `BLENDER_PIPELINE_API_ENDPOINT` and an owner-only
  secret file named by `BLENDER_PIPELINE_API_KEY_FILE`. Dry runs do not read
  credentials, download media, call a model, or write a run directory.
- Add `--render-tutorial-html` only when a human-facing display copy is useful.
  It is rendered from the same complete Markdown without a second model call and
  never replaces `tutorial.md`.

## Asset delivery

Follow the selected recipe's `distribution_contract.asset_delivery` exactly:

- `bundled-open`: allowed only with package-local source, exact hash, SPDX
  identifier, and package-local license evidence.
- `user-supplied`: require a lawful local `--asset`; never fetch, publish, or
  commit it or the isolated staged copy.
- `blocked`: stop. An adapter, public URL, or matching-looking asset does not
  unlock the recipe.

Read [references/execution-contract.md](references/execution-contract.md) when
adding a recipe or diagnosing a validation failure.
```

## File: skills/blender-pipeline/SKILL.md
size: 4065
sha: 6ad41d6c678359640821f0ae46b5048fb156f5bf
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/SKILL.md

```text
---
name: blender-pipeline
description: Extract a tutorial or reconstruct a Blender result from video links, local videos with supporting assets, or Markdown tutorials in Codex chat. Clarify the intended output when unspecified; also route explicit showcase reproduction and independent asset edits.
---

# Blender Pipeline

## Start from the Codex client

This is the user-facing Codex launcher. If the requested output is unclear, ask
whether the user wants only a tutorial or a complete Blender reconstruction;
wait for their choice before launching. Do not ask again when the goal is explicit.

Read [references/codex-launch.md](references/codex-launch.md), interpret the
user's natural-language inputs, and invoke this skill's
`scripts/launch_from_codex.py` yourself. It calls the same maintained pipeline
as the API entrypoint. Tutorial-only stops after preparation; full reconstruction
continues through knowledge retrieval → Blender generation → render and review.

A video with an accompanying `.blend`, preview, texture, or dependency bundle
retains those inputs in either selected route; it is not an independent edit.
A supplied Markdown tutorial skips video extraction: prepare it for tutorial-only,
or continue knowledge-backed generation for reconstruction. No RW1 is required.

Use the user's requested output location or established data root. Ask only for
missing information needed to run, not command-line flags or API credentials.
The Codex path uses the signed-in Codex CLI; the user need not run a Python
launcher manually. `run_codex.py` remains a compatibility entrypoint, not the
client interaction. Requests to explain, inspect, or dry-run do not authorize
an actual reconstruction.

## Extract a tutorial from video

For tutorial-only, pass `--extract-only` and do not start reconstruction. Read
[tutorial-extraction/SKILL.md](tutorial-extraction/SKILL.md) for illustrated
Markdown, learner inputs and the separate rubric; both replay routes reuse it.

## Reproduce a maintained showcase

Read [reproduction/SKILL.md](reproduction/SKILL.md) only for an explicitly
requested catalog recipe or hybrid-delivery workflow. A tutorial's subject
also appearing on the showcase does not change ordinary replay routing.
Public previews do not authorize downloading the underlying assets.

## Generate from zero

For ordinary video/tutorial requests use the client launcher above. Use the
specialized generation mode for an explicit from-zero reference/text task or
low-level generation work, with no authoritative starting project.

Read [generation/SKILL.md](generation/SKILL.md), then load
[knowledge/generation.md](knowledge/generation.md),
[knowledge/evidence-and-routing.md](knowledge/evidence-and-routing.md), and only
the relevant sections of
[knowledge/rendering-and-dynamics.md](knowledge/rendering-and-dynamics.md).

## Edit an existing asset

Use editing for a standalone change request on an existing asset, without a
video/tutorial reconstruction workflow. A generated replacement object within
that scoped change remains part of the edit.

Read [editing/SKILL.md](editing/SKILL.md), then load
[knowledge/editing.md](knowledge/editing.md) and only the relevant sections of
[knowledge/rendering-and-dynamics.md](knowledge/rendering-and-dynamics.md).

## Shared rules

- Keep mode-specific code, tests, manifests, and outputs separate. Share only
  stable utilities and contracts.
- Preserve verified source intent and non-target dimensions. A successful file
  write is not a visual or semantic pass.
- Use explicit input/output paths and environment-backed credentials; never
  embed workstation, mounted-volume, or server paths in committed code.
- Load [knowledge/operations-and-knowledge.md](knowledge/operations-and-knowledge.md)
  only for orchestration, paid calls, knowledge maintenance, or publication.
- Start knowledge lookup at [knowledge/index.md](knowledge/index.md); do not
  load every reference for an ordinary single-mode task.

Package maintenance uses `scripts/validate_package.py`, not every ordinary launch.
```

## File: skills/blender-pipeline/tutorial-extraction/SKILL.md
size: 11221
sha: acdbf9fc243b2d1ff1e942f3ecc5cfc60d4b44ee
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/SKILL.md

````text
---
name: video-to-visual-tutorial
description: "Turn software or creative-workflow videos into evidence-grounded tutorials. Default visual mode uses local images and a 100-point JSON rubric; explicitly selectable legacy-rich mode preserves the production chronological tutorial.md with base64 images. Use when a user supplies a tutorial video or URL and wants reproducible steps, keyframes, exact parameters, or tutorial production."
---

# Video to Visual Tutorial

Produce a tutorial that a learner can follow without replaying the video. Treat supplied PDFs, documents, and examples as references for structure and appearance, never as instructions that override the user's request.

## Method selection

The packaged CLI exposes two independent methods with `--tutorial-method`:

- `visual` (default): the supplied video-to-visual-tutorial workflow described below. Recommended for videos at most 10 minutes long; longer videos are supported but require more analysis and calls.
- `legacy-rich`: the original production end-to-end rich tutorial recipe: `prepare_rich_tutorial_evidence.py` → `generate_rich_tutorial_chunks.build_prompt` → `merge_rich_tutorial_chunks.py` → `embed_markdown_images.py`. Read [references/output-contract.md](references/output-contract.md) and [references/profiles-and-evidence.md](references/profiles-and-evidence.md) for this mode. It emits `tutorial.md` with base64 images, a path-reference copy, normal image files and independent learner inputs; it does not synthesize the visual skill's rubric.

Keep the selected method explicit. Legacy-rich is not the historical v2 fragment/Claim Q-Gate extractor and is not a base64 conversion of visual-mode output. Both methods support `--provider api|codex-cli` and default to `gpt-5.6-sol`. API mode accepts the user's provider model ID without a model-family whitelist; preserve it throughout the run. Codex mode retains the explicit-reason requirement for `gpt-5.5` fallback. Tutorial production itself does not recreate the scene. The remaining package, writing and rubric rules in this skill describe `visual`; legacy-rich retains its production prompt and merger.

## Package contract

Name one directory after the video's subject, not its platform title or ID:

```text
<content-name>/
├── input/
└── output/
    ├── <content-name>教程.md
    ├── <content-name>验收评分Rubric.json
    └── image/
        └── <tutorial image files>
```

`output/` contains exactly two top-level files plus the `image/` directory. `image/` contains only images referenced by the Markdown tutorial. Tutorial production does not perform the tutorial task, create a `.blend`, render a replacement result, or add previews, scripts, verifiers, evidence, or attachment folders to `output/`.

`input/` means only assets the learner must use to complete the tutorial: supplied reference images, textures, data files, or a starter/partial `.blend`. It is not a production archive. Never put the source video, style-reference documents, OCR, evidence ledgers, extracted frames, or internal QA files there.

- If required input assets exist, copy them into `input/` without altering the originals, preserve meaningful filenames and relative paths, and list them in the tutorial's `You will need` section. Tell the learner whether to open, import, link, or save a working copy of each asset.
- If the video supplies no required assets, leave `input/` completely empty. Do not add a README or placeholder. State in `You will need` that no input asset is provided and explain the starting scene.
- Keep source analysis and reference documents in a working cache outside the final tutorial directory.

Default Blender compatibility is 4.1 and 5.1.2 unless the user specifies otherwise. Do not claim compatibility that was not checked.

## Evidence-first workflow

1. Inspect any reference deliverable for hierarchy, recurring blocks, image treatment, and QA expectations. Reuse its information architecture, not its subject matter.
2. Acquire only the source material needed for analysis. Record title, creator, stable ID or URL, duration, dimensions, and publication metadata. Do not invent a transcript when the video is driven by on-screen UI and captions.
3. Run `scripts/prepare_video.py` on a local video to create a coarse contact sheet, timestamped frames, and optional OCR. Start at 2-second intervals for videos under 2 minutes, 5–10 seconds for medium videos, and 15–30 seconds for long videos.
4. Inspect the contact sheet once. Open individual frames only at operation changes, parameter edits, ambiguous UI states, or final results. Increase sampling locally instead of decoding the whole video at high density.
5. Build a compact evidence ledger using [references/evidence-ledger.md](references/evidence-ledger.md). Every exact parameter, node connection, command, and operation order must point to a timestamp/frame. Label useful additions that are not shown as `recommendation`; do not present them as video facts.
6. Group adjacent micro-actions by learner intent. A step normally contains a time range, outcome-oriented title, concise actions, one representative frame, a visible success criterion, and one practical correction.
7. Author the tutorial as Markdown and the rubric as JSON for different audiences. Follow [references/markdown-layout.md](references/markdown-layout.md) and [references/blender-capability-rubric.md](references/blender-capability-rubric.md).
8. Run `scripts/validate_visual_package.py` and preview the Markdown in a renderer that resolves local relative paths. Fix broken image references, unreadable screenshots, mismatched captions, unsupported claims, invalid JSON, scoring gaps, and verifier mismatches before delivery.

## Tutorial writing rules

- Include a visible `You will need` section near the start. State the supported Blender versions and only the assets the learner actually receives in `input/`. If `input/` is empty, say so plainly and name the starting scene.
- Preserve operation order. For Blender, independently verify modifier order, node wiring, and numeric fields; visually similar outcomes can come from materially different graphs.
- Copy values from the clearest frame, not OCR alone. If a value is unreadable, give a bounded visual criterion or mark it unspecified; never manufacture precision.
- Use the application's vocabulary. Add English UI names only when useful across localized interfaces or versions.
- A screenshot must show the operation it accompanies. Prefer the frame after the decisive edit, with both the setting and its result visible.
- Every tutorial image comes from the source video or a learner input asset. The first image must be an actual source-video frame, normally the clearest final-result frame. Never substitute a newly modeled or newly rendered image.
- Copy tutorial images into `output/image/` and use Markdown image syntax with a descriptive caption and a relative target such as `image/frame_001.jpg`. Do not use absolute paths, remote image URLs, data URLs, or paths that leave `output/`.
- Keep only referenced images in `output/image/`; do not use that directory as an evidence dump.
- Tutorial production is documentation work only. Do not open Blender to recreate the task, build a solution artifact, or render a new result unless the user separately requests that work.
- Write as a practical human instructor. Avoid promotional filler, synthetic summaries, and decorative claims such as “7 steps · images and natural language · no code.” Do not expose internal taxonomy tags in the tutorial unless they help the learner.
- The tutorial is given to the task-performing agent. Do not mention the rubric, verifier, check IDs, grading thresholds, hidden solution files, or production-side evidence in it.
- Keep `shown`, `inferred`, and `recommendation` distinct in the evidence ledger. Only `shown` claims may be phrased as exact facts from the video.

## Scoring and artifact verification

- The rubric totals exactly 100 points and is emitted as UTF-8 JSON.
- Use only these eight capability labels: `GEO`, `PROC`, `SURF`, `SCN`, `RIG`, `ANM`, `SIM`, `PIPE`.
- Include only capabilities and rows that actually receive points. Do not list unused labels or reproduce the full taxonomy in each rubric.
- Every scored row has a unique check ID, point value, observable acceptance rule, and matching artifact verifier check. A label without a verifier is not scored.
- The verifier reports `PASS`, `PARTIAL`, or `FAIL`, worth 100%, 50%, or 0% of that row unless the rubric explicitly defines another deterministic mapping.
- Because `output/` may contain only the tutorial, rubric, and tutorial images, embed the non-destructive Blender Python verifier source inside the rubric JSON. It must inspect the future submitted `.blend`, produce a JSON score report, and work in both 4.1 and 5.1.2 when feasible.
- Never award points solely from screenshots, prose, or filenames when the underlying `.blend` state is inspectable.
- The grading JSON contains only scoring metadata, scored rows, category totals, status weights, and the embedded artifact verifier. It contains no checklist, learner instructions, human-review section, grading record, unused capability labels, or general capability catalog.

## Token-efficient batch behavior

- Reuse metadata, contact sheets, OCR, evidence ledgers, crop coordinates, document styles, and rubric templates across retries. Do not repeatedly inspect the raw video.
- Keep raw OCR out of the writing context after claims are resolved; the ledger is the source of truth.
- Use one representative image per step unless a before/after comparison is essential.
- Generate the Markdown tutorial, its copied image assets, and JSON rubric in one build pass. Preview only the Markdown sections whose images or layout need inspection.
- Validate check IDs and points programmatically. Spend model attention on ambiguous evidence and visual QA, not deterministic arithmetic.
- Stop expanding once every distinct user-visible operation, exact value, success criterion, attachment, and final check is covered.

## Deliverables

Return the tutorial directory with an empty or correctly populated `input/`, exactly two top-level files under `output/` (the Markdown tutorial and JSON rubric), and an `output/image/` directory containing only tutorial images. Preserve source attribution in the tutorial, but do not include the source video, reference documents, generated Blender files, rendered results, evidence, or production helpers in the final directory unless a source asset is itself a required learner input.

## Pipeline entrypoint

For the packaged CLI, use `scripts/extract_video_tutorial.py`; read
[references/output-contract.md](references/output-contract.md) for input assets,
workspace integration, optional HTML, and existing generation/reproduction callers.
The CLI defaults to this visual skill and also preserves the independently
selectable production `legacy-rich` recipe. Neither method invokes the legacy
v2 fragment extractor.
Read [references/profiles-and-evidence.md](references/profiles-and-evidence.md)
when selecting cost and sampling settings.
````

## File: skills/blender-pipeline/scripts/inspect_input_asset.py
size: 6480
sha: 23454ef09243aabc64c0ee56f69e0e9ee6b38787
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/scripts/inspect_input_asset.py

```text
"""Trusted Blender-side, non-saving inspection of a staged source asset."""

import argparse
import hashlib
import json
import re
import sys
from pathlib import Path

import bpy

def image_dependency_paths(item, path: Path) -> list[Path]:
    """Resolve declared UDIM tiles, rather than looking for a literal token."""
    if item.source != "TILED":
        return [path]
    tiles = list(item.tiles)
    if not tiles:
        return [path]
    value = str(path)
    result = []
    for tile in tiles:
        number = int(tile.number)
        if "<UDIM>" in value:
            target = value.replace("<UDIM>", str(number))
        elif "<UVTILE>" in value:
            target = value.replace(
                "<UVTILE>", f"u{(number - 1001) % 10 + 1}_v{(number - 1001) // 10 + 1}"
            )
        else:
            # Blender may retain the first concrete tile name instead of a
            # token. Replace only a standalone conventional four-digit tile ID.
            target, count = re.subn(
                r"(?<!\d)1\d{3}(?!\d)(?=[^/\\]*$)", str(number), value, count=1
            )
            if not count and len(tiles) > 1:
                return []
        result.append(Path(target).resolve())
    return result

def mesh_topology_summary(mesh) -> dict:
    """Describe the stored mesh without welding vertices or applying modifiers."""
    face_uses = [0] * len(mesh.edges)
    for polygon in mesh.polygons:
        for loop_index in polygon.loop_indices:
            face_uses[mesh.loops[loop_index].edge_index] += 1
    positions = set()
    coincident = 0
    for vertex in mesh.vertices:
        position = tuple(vertex.co)
        if position in positions:
            coincident += 1
        else:
            positions.add(position)
    return {
        "vertices": len(mesh.vertices),
        "edges": len(mesh.edges),
        "faces": len(mesh.polygons),
        "boundary_edges": sum(count == 1 for count in face_uses),
        "nonmanifold_edges": sum(count != 2 for count in face_uses),
        "coincident_vertex_count": coincident,
    }

def inspect(asset: Path, root: Path) -> dict:
    if asset.suffix.lower() != ".blend":
        # Interchange files do not replace the current scene. Factory startup
        # contains a cube, camera and lamp that must not become source assets.
        bpy.ops.wm.read_factory_settings(use_empty=True)
    if asset.suffix.lower() == ".blend":
        bpy.ops.wm.open_mainfile(filepath=str(asset), load_ui=False, use_scripts=False)
    elif asset.suffix.lower() == ".fbx":
        bpy.ops.import_scene.fbx(filepath=str(asset))
    elif asset.suffix.lower() in {".glb", ".gltf"}:
        bpy.ops.import_scene.gltf(filepath=str(asset))
    elif asset.suffix.lower() == ".obj":
        bpy.ops.wm.obj_import(filepath=str(asset))
    issues = []
    images = []
    for item in bpy.data.images:
        if item.source not in {"FILE", "TILED", "SEQUENCE", "MOVIE"}:
            continue
        packed = bool(item.packed_file or item.packed_files)
        path = Path(bpy.path.abspath(item.filepath, library=item.library)).resolve()
        dependencies = image_dependency_paths(item, path) if not packed else []
        if not packed and (
            not dependencies
            or any(not p.is_file() or not p.is_relative_to(root) for p in dependencies)
        ):
            issues.append(
                f"Image dependency is missing or outside the staged bundle: {item.name}"
            )
        images.append(
            {
                "name": item.name,
                "packed": packed,
                "path": str(path) if not packed else None,
                "tile_paths": [str(p) for p in dependencies]
                if item.source == "TILED"
                else [],
            }
        )
    for lib in bpy.data.libraries:
        path = Path(bpy.path.abspath(lib.filepath)).resolve()
        if not path.is_file() or not path.is_relative_to(root):
            issues.append(
                f"Linked library is missing or outside the staged bundle: {lib.name}"
            )
    for material in bpy.data.materials:
        if material.use_nodes and material.node_tree:
            if any(n.bl_idname == "NodeUndefined" for n in material.node_tree.nodes):
                issues.append(f"Unsupported shader node in material: {material.name}")
    return {
        "schema": "blender-pipeline-input-audit.v1",
        "selected_model_sha256": hashlib.file_digest(
            asset.open("rb"), "sha256"
        ).hexdigest()
        if hasattr(hashlib, "file_digest")
        else hashlib.sha256(asset.read_bytes()).hexdigest(),
        "status": "blocked" if issues else "pass",
        "issues": issues,
        "blender_version": bpy.app.version_string,
        "topology_fact_definitions": {
            "scope": "Stored mesh, before modifier evaluation; no topology was changed.",
            "boundary_edges": "Edges incident to exactly one polygon.",
            "nonmanifold_edges": "Edges incident to other than two polygons, including boundary and loose edges.",
            "coincident_vertex_count": "Vertices beyond the first at exactly identical object-local coordinates; no tolerance-based merging is inferred.",
        },
        "objects": [
            {
                "name": o.name,
                "type": o.type,
                **(
                    mesh_topology_summary(o.data)
                    if o.type == "MESH"
                    else {"vertices": None}
                ),
                "materials": [m.name if m else None for m in o.data.materials]
                if hasattr(o.data, "materials")
                else [],
                "modifiers": [m.type for m in o.modifiers],
            }
            for o in bpy.context.scene.objects
        ],
        "images": images,
        "frame_range": [bpy.context.scene.frame_start, bpy.context.scene.frame_end],
    }

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--asset", type=Path, required=True)
    parser.add_argument("--root", type=Path, required=True)
    parser.add_argument("--output", type=Path, required=True)
    args = parser.parse_args(sys.argv[sys.argv.index("--") + 1 :])
    result = inspect(args.asset.resolve(), args.root.resolve())
    args.output.write_text(
        json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8"
    )
    if result["issues"]:
        raise RuntimeError("; ".join(result["issues"]))
```

## File: skills/blender-pipeline/scripts/launch_from_codex.py
size: 412
sha: ac42512641b3b8eee86b82bf47a31482d85b07e3
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/scripts/launch_from_codex.py

```text
#!/usr/bin/env python3
"""Run the shared reproduction pipeline from the selectable Codex skill."""

import sys
from pathlib import Path

sys.dont_write_bytecode = True
sys.path.insert(0, str(Path(__file__).resolve().parent))

import pipeline_launcher

def main(argv: list[str] | None = None) -> int:
    return pipeline_launcher.main("codex-cli", argv)

if __name__ == "__main__":
    raise SystemExit(main())
```

## File: skills/blender-pipeline/scripts/pipeline_launcher.py
size: 31972
sha: 3c50e923aa17061e65dabcfdd0d10facad0b5472
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/scripts/pipeline_launcher.py

```text
"""Portable, explicit-input entry point to the maintained replay pipeline.

Dataset acquisition, showcase recipe enablement, and knowledge promotion are
deliberately not launcher responsibilities.
"""

from __future__ import annotations

import argparse
import getpass
import hashlib
import importlib.util
import json
import os
import shutil
import subprocess
import sys
from pathlib import Path
from urllib.parse import urlparse

HERE = Path(__file__).resolve().parent
PIPELINE = HERE.parent
REPO = PIPELINE.parent.parent
GENERATION = PIPELINE / "generation/scripts"
EXTRACTION = PIPELINE / "tutorial-extraction/scripts"
MODEL_FORMATS = {".blend", ".glb", ".gltf", ".obj", ".fbx"}
IMAGE_FORMATS = {".png", ".jpg", ".jpeg", ".webp", ".tif", ".tiff", ".exr", ".hdr"}

def digest(path: Path) -> str:
    result = hashlib.sha256()
    with path.open("rb") as stream:
        for block in iter(lambda: stream.read(1024 * 1024), b""):
            result.update(block)
    return result.hexdigest()

def write_json(path: Path, value: object) -> None:
    path.write_text(
        json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
    )

def parser(provider: str) -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(
        description=f"Tutorial → knowledge-assisted Blender reproduction ({provider}). No RW1 dataset required."
    )
    p.add_argument(
        "--config",
        type=Path,
        help="JSON config; CLI overrides config, then environment",
    )
    p.add_argument(
        "--configure",
        action="store_true",
        help="API only: interactively create private endpoint/key configuration outside the repository",
    )
    source = p.add_mutually_exclusive_group()
    source.add_argument("--video-file", type=Path)
    source.add_argument("--video-url")
    source.add_argument(
        "--tutorial",
        type=Path,
        help="Existing Markdown tutorial with numbered operation headings and local/base64 images",
    )
    p.add_argument("--title", help="Tutorial title; defaults to the input filename")
    p.add_argument(
        "--asset",
        type=Path,
        help="Authoritative starting .blend/.glb/.gltf/.obj/.fbx; never overwritten",
    )
    p.add_argument(
        "--asset-root",
        type=Path,
        help="Optional authorized dependency bundle root containing --asset; copies this complete directory",
    )
    p.add_argument(
        "--input-asset",
        type=Path,
        action="append",
        default=[],
        help="Supporting texture/file/directory, repeatable",
    )
    p.add_argument(
        "--preview",
        type=Path,
        action="append",
        default=[],
        help="Input/starting-state preview, not the final target; repeatable",
    )
    p.add_argument(
        "--target-image",
        type=Path,
        help="Optional finished-result reference, distinct from --preview",
    )
    p.add_argument(
        "--output-dir",
        type=Path,
        help="New empty run directory outside the repository (required)",
    )
    p.add_argument(
        "--tutorial-method", choices=("visual", "legacy-rich"), default="visual"
    )
    p.add_argument(
        "--profile", choices=("economy", "balanced", "forensic"), default="balanced"
    )
    p.add_argument(
        "--model",
        choices=("gpt-5.6-sol", "gpt-5.5") if provider == "codex-cli" else None,
        help="API: provider model ID; overrides the model saved in --config",
    )
    p.add_argument(
        "--fallback-reason",
        default="",
        help="Codex only: required when selecting gpt-5.5 after sol is unavailable; optional API annotation",
    )
    p.add_argument("--transcript", type=Path)
    p.add_argument("--asr-language", default="auto")
    p.add_argument(
        "--render-html",
        action="store_true",
        help="Also render a human-readable tutorial; no extra model call",
    )
    p.add_argument(
        "--extract-only",
        action="store_true",
        help="Stop after tutorial preparation, before Blender generation",
    )
    p.add_argument(
        "--max-extraction-calls",
        type=int,
        help="Hard total extraction-call cap, including repair",
    )
    p.add_argument(
        "--max-replay-calls",
        type=int,
        default=8,
        help="Codegen and visual review call cap (default: 8)",
    )
    p.add_argument(
        "--max-replay-tokens",
        type=int,
        default=500000,
        help="Replay ledger token reservation cap",
    )
    p.add_argument(
        "--repair-attempts",
        type=int,
        choices=(1, 2, 3),
        default=2,
        help="Total replay attempts, including the initial attempt",
    )
    p.add_argument("--blender", help="Blender executable path")
    p.add_argument(
        "--endpoint", help="API only: credential-free HTTPS Chat Completions endpoint"
    )
    p.add_argument(
        "--api-key-file",
        type=Path,
        help="API only: private key file outside repository; POSIX mode 0600",
    )
    p.add_argument(
        "--check",
        action="store_true",
        help="One small real model request plus local executable checks; does not claim asset reproduction",
    )
    p.add_argument(
        "--dry-run",
        action="store_true",
        help="Print the execution plan; no writes, downloads, credential reads, or model calls",
    )
    return p

def existing(path: Path, *, directory: bool = False) -> Path:
    resolved = path.expanduser().resolve(strict=True)
    if not (resolved.is_dir() if directory else resolved.is_file()):
        raise ValueError(f"Not a {'directory' if directory else 'file'}: {path}")
    return resolved

def external(path: Path) -> Path:
    path = path.expanduser().resolve()
    if path == REPO or path.is_relative_to(REPO):
        raise ValueError(
            "Run outputs and private configuration must be outside the code repository"
        )
    return path

def endpoint_url(value: str) -> str:
    p = urlparse(value)
    if (
        p.scheme != "https"
        or not p.netloc
        or p.username
        or p.password
        or p.query
        or p.fragment
    ):
        raise ValueError(
            "Use a credential-free HTTPS Chat Completions endpoint (no query/fragment)"
        )
    if not p.path.rstrip("/").endswith("/chat/completions"):
        raise ValueError("Endpoint must end with /chat/completions")
    return value.rstrip("/")

def model_id(value: str) -> str:
    """Validate a provider ID without substituting or rewriting the selection."""
    if (
        not isinstance(value, str)
        or not value
        or value != value.strip()
        or len(value) > 256
        or not all(character.isprintable() for character in value)
    ):
        raise ValueError(
            "Model must be a nonempty single-line provider ID (up to 256 characters)"
        )
    return value

def configure(args: argparse.Namespace, provider: str) -> int:
    if provider != "api" or not args.config:
        raise ValueError(
            "Use run_api.py --configure --config /private/path/pipeline.json"
        )
    dest = external(args.config)
    key_path = dest.parent / "model_api_key"
    if dest.exists() or key_path.exists():
        raise ValueError(
            "Configuration/key already exists; choose a new location or edit your existing configuration"
        )
    endpoint = endpoint_url(input("HTTPS Chat Completions endpoint: ").strip())
    key = getpass.getpass("API key (hidden): ").strip()
    if not key or "\n" in key:
        raise ValueError("An API key is required")
    model = model_id(
        args.model
        if args.model is not None
        else input("Model [gpt-5.6-sol]: ").strip() or "gpt-5.6-sol"
    )
    dest.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
    created = []

    def write_private(path: Path, content: str) -> None:
        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
        created.append(path)
        with os.fdopen(fd, "w", encoding="utf-8") as stream:
            metadata = os.fstat(stream.fileno())
            if os.name == "posix" and (
                metadata.st_mode & 0o777 != 0o600 or metadata.st_uid != os.getuid()
            ):
                raise ValueError(
                    "Private configuration requires owner-only POSIX mode 0600. "
                    "Choose a private local configuration directory on a filesystem "
                    "that supports these permissions, not exFAT."
                )
            stream.write(content)

    try:
        write_private(key_path, key)
        write_private(
            dest,
            json.dumps(
                {
                    "endpoint": endpoint,
                    "api_key_file": str(key_path),
                    "model": model,
                },
                ensure_ascii=False,
                indent=2,
            )
            + "\n",
        )
    except BaseException:
        # Roll back only files exclusively created by this invocation. Never
        # report a usable configuration when its filesystem ignored 0600.
        for path in reversed(created):
            path.unlink(missing_ok=True)
        raise
    print(f"Private configuration created: {dest}")
    return 0

def settings(args: argparse.Namespace, provider: str) -> dict:
    config = json.loads(existing(args.config).read_text()) if args.config else {}
    if not isinstance(config, dict) or set(config) - {
        "endpoint",
        "api_key_file",
        "model",
        "blender",
    }:
        raise ValueError(
            "Config supports only endpoint, api_key_file, model, blender; never put an inline API key in it"
        )
    if any(
        not isinstance(value, str) or not value.strip() for value in config.values()
    ):
        raise ValueError("Every configuration value must be a nonempty string")
    model = model_id(
        args.model if args.model is not None else config.get("model", "gpt-5.6-sol")
    )
    if provider == "codex-cli":
        if model not in {"gpt-5.6-sol", "gpt-5.5"}:
            raise ValueError(
                "Codex model must be gpt-5.6-sol, or explicit gpt-5.5 fallback"
            )
        if (model == "gpt-5.5") != bool(args.fallback_reason.strip()):
            raise ValueError(
                "gpt-5.5 requires --fallback-reason; omit that reason for gpt-5.6-sol"
            )
    if args.max_replay_calls < 1 or args.max_replay_tokens < 1:
        raise ValueError("Replay budgets must be positive")
    if args.max_extraction_calls is not None and args.max_extraction_calls < 1:
        raise ValueError("--max-extraction-calls must be positive")
    endpoint = (
        args.endpoint
        or config.get("endpoint")
        or os.environ.get("BLENDER_PIPELINE_API_ENDPOINT", "")
    )
    key = (
        args.api_key_file
        or config.get("api_key_file")
        or os.environ.get("BLENDER_PIPELINE_API_KEY_FILE", "")
    )
    blender = (
        args.blender
        or config.get("blender")
        or os.environ.get("BLENDER_PIPELINE_BLENDER")
        or shutil.which("blender")
    )
    if (
        not blender
        and Path("/Applications/Blender.app/Contents/MacOS/Blender").is_file()
    ):
        blender = "/Applications/Blender.app/Contents/MacOS/Blender"
    needs_model = args.check or not (args.tutorial and args.extract_only)
    if provider == "api" and not args.dry_run and needs_model:
        endpoint = endpoint_url(endpoint)
        if not key:
            raise ValueError("API requires --config, or --endpoint and --api-key-file")
        key = external(existing(Path(key)))
        if os.name == "posix" and (key.stat().st_mode & 0o777) != 0o600:
            raise ValueError(
                "API key file must have mode 0600; run chmod 600 on that private file"
            )
    if (
        provider == "codex-cli"
        and not args.dry_run
        and needs_model
        and not shutil.which("codex")
    ):
        raise ValueError(
            "Codex CLI is not installed/on PATH; install it and run codex login first"
        )
    if not args.dry_run and (not args.extract_only or args.asset):
        if not blender:
            raise ValueError("Blender not found; specify --blender /path/to/blender")
        blender = str(existing(Path(shutil.which(str(blender)) or blender)))
    return {
        "model": model,
        "endpoint": endpoint,
        "key": str(key),
        "blender": blender or "blender",
    }

def check_dependencies(args: argparse.Namespace, options: dict) -> None:
    modules = ["PIL", "requests", "jsonschema"]
    if args.render_html:
        modules.append("markdown")
    absent = [name for name in modules if importlib.util.find_spec(name) is None]
    if absent:
        raise ValueError(
            "Missing Python packages: "
            + ", ".join(absent)
            + "; install requirements.txt"
        )
    if not (args.tutorial and args.extract_only and not args.check):
        for executable in ("ffmpeg", "ffprobe"):
            if not shutil.which(executable):
                raise ValueError(
                    f"Missing {executable}; install FFmpeg and add it to PATH"
                )
    if args.video_url and importlib.util.find_spec("yt_dlp") is None:
        raise ValueError(
            "Missing yt-dlp; install requirements.txt or supply --video-file"
        )
    if args.check:
        result = subprocess.run(
            [options["blender"], "--version"],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            timeout=20,
        )
        if result.returncode:
            raise ValueError("Configured Blender executable failed its version check")

def safe_copy(source: Path, target: Path) -> None:
    if source.is_dir() and target.resolve().is_relative_to(source.resolve()):
        raise ValueError("Output cannot be nested inside a supporting input directory")
    if source.is_symlink() or (
        source.is_dir() and any(p.is_symlink() for p in source.rglob("*"))
    ):
        raise ValueError(
            f"Input bundle contains symlinks; supply a self-contained copy: {source}"
        )
    if target.exists():
        raise ValueError(
            f"Input name collision: {target.name}; use --asset-root to preserve a complete bundle"
        )
    target.parent.mkdir(parents=True, exist_ok=True)
    if source.is_dir():
        shutil.copytree(
            source, target, ignore=shutil.ignore_patterns("._*", ".DS_Store")
        )
    else:
        shutil.copy2(source, target)

def command(argv: list[str], env: dict, *, log: Path | None = None) -> None:
    if log:
        with log.open("w", encoding="utf-8") as stream:
            result = subprocess.run(
                argv, env=env, stdout=stream, stderr=subprocess.STDOUT
            )
    else:
        result = subprocess.run(argv, env=env)
    if result.returncode:
        raise RuntimeError(
            f"Stage {Path(argv[1] if argv[0] == sys.executable else argv[0]).name} exited {result.returncode}"
            + (f"; details: {log}" if log else "")
        )

def runtime_env(
    out: Path, options: dict, provider: str, args: argparse.Namespace
) -> dict:
    env = os.environ.copy()
    # A new public run must not inherit a private dataset worker's path or GPU policy.
    for name in list(env):
        if name.startswith(
            (
                "RW1_",
                "RW2_",
                "TOTAL_ASSET_",
                "VIDEO_REPLAY_",
                "BLENDER_KNOWLEDGE_",
                "VIDEO2BLENDER_",
                "PAPER12_",
            )
        ):
            env.pop(name)
    control = out / ".control"
    temp = control / "tmp"
    temp.mkdir(parents=True, exist_ok=True)
    env.update(
        {
            "PYTHONDONTWRITEBYTECODE": "1",
            "TMPDIR": str(temp),
            "TEMP": str(temp),
            "TMP": str(temp),
            "XDG_CACHE_HOME": str(control / "cache"),
            "HF_HOME": str(control / "cache/huggingface"),
            "TORCH_HOME": str(control / "cache/torch"),
            "MPLCONFIGDIR": str(control / "cache/matplotlib"),
            "VIDEO2BLENDER_OUTPUT_ROOT": str(out),
            "VIDEO2BLENDER_CONFIG_ROOT": str(control),
            "VIDEO2BLENDER_KEEP_TRACE_IN_PLACE": "1",
            "BLENDER_KNOWLEDGE_ROOT": str(control / "knowledge"),
            "VIDEO_REPLAY_PAID_API_LEDGER": str(control / "model_ledger.sqlite3"),
            "VIDEO_REPLAY_PAID_API_MAX_CALLS_PER_ASSET": str(args.max_replay_calls),
            "VIDEO_REPLAY_PAID_API_GLOBAL_MAX_CALLS": str(args.max_replay_calls),
            "VIDEO_REPLAY_PAID_API_MAX_TOKENS_PER_ASSET": str(args.max_replay_tokens),
            "BLENDER_PIPELINE_PROVIDER": provider,
            "BLENDER_PIPELINE_MODEL": options["model"],
            "BLENDER_PIPELINE_BLENDER": options["blender"],
            "BLENDER_PIPELINE_RENDER_DEVICE_POLICY": "local",
            "VIDEO2BLENDER_RENDER_ENGINE": "CYCLES",
            "BLENDER_PIPELINE_FILM_TRANSPARENT": os.environ.get(
                "BLENDER_PIPELINE_FILM_TRANSPARENT", "0"
            ),
            "VIDEO2BLENDER_CYCLES_BACKEND": os.environ.get(
                "VIDEO2BLENDER_CYCLES_BACKEND", "CPU"
            ),
            "BLENDER_PIPELINE_REPAIR_ATTEMPTS": str(args.repair_attempts - 1),
            "BLENDER_PIPELINE_VISUAL_REVIEW": "1",
        }
    )
    if provider == "api":
        env.update(
            {
                "BLENDER_PIPELINE_API_ENDPOINT": options["endpoint"],
                "BLENDER_PIPELINE_API_KEY_FILE": options["key"],
                "VIDEO_REPLAY_APPROVED_PAID_API_ENDPOINT": options["endpoint"],
            }
        )
    else:
        env.pop("BLENDER_PIPELINE_API_KEY_FILE", None)
        env.pop("BLENDER_PIPELINE_API_ENDPOINT", None)
    return env

def stage_inputs(
    args: argparse.Namespace, out: Path, title: str, env: dict, options: dict
) -> list[Path]:
    linked = out / "linked_source"
    linked.mkdir()
    source_asset = existing(args.asset) if args.asset else None
    staged_asset = None
    if args.asset_root:
        root = existing(args.asset_root, directory=True)
        if not source_asset or not source_asset.is_relative_to(root):
            raise ValueError("--asset-root must contain --asset")
        if out.is_relative_to(root):
            raise ValueError("Output cannot be nested inside the input bundle")
        for item in root.iterdir():
            if item.name.startswith("._") or item.name == ".DS_Store":
                continue
            safe_copy(item, linked / item.name)
        staged_asset = linked / source_asset.relative_to(root)
    elif source_asset:
        staged_asset = linked / source_asset.name
        safe_copy(source_asset, staged_asset)
    records = []
    learner = [linked] if args.asset_root else ([staged_asset] if staged_asset else [])
    for role, paths in (("supporting", args.input_asset), ("preview", args.preview)):
        for raw in paths:
            source = raw.expanduser().resolve(strict=True)
            if (
                role == "supporting"
                and args.asset_root
                and source.is_relative_to(existing(args.asset_root, directory=True))
            ):
                target = linked / source.relative_to(
                    existing(args.asset_root, directory=True)
                )
            else:
                target = (
                    linked if role == "supporting" else out / "input_previews"
                ) / source.name
            if not target.exists():
                safe_copy(source, target)
            elif not args.asset_root or not source.is_relative_to(
                existing(args.asset_root, directory=True)
            ):
                raise ValueError("Duplicate input basename: " + source.name)
            if not args.asset_root or not target.is_relative_to(linked):
                learner.append(target)
            files = sorted(target.rglob("*")) if target.is_dir() else [target]
            for path in files:
                if (
                    path.is_file()
                    and not path.name.startswith("._")
                    and path.name != ".DS_Store"
                ):
                    records.append(
                        {"path": str(path), "role": role, "sha256": digest(path)}
                    )
    # List the bundle's packed/external image assets even if no --input-asset was needed.
    for path in sorted(linked.rglob("*")):
        if (
            path.is_file()
            and not path.name.startswith("._")
            and path.suffix.lower() in IMAGE_FORMATS
            and str(path) not in {r["path"] for r in records}
        ):
            records.append(
                {"path": str(path), "role": "supporting", "sha256": digest(path)}
            )
    write_json(
        out / "input_assets.json",
        {"schema": "blender-pipeline-input-assets.v1", "assets": records},
    )
    info = {
        "title": title,
        "source_kind": "video_replay_type2" if source_asset else "video_replay",
        "webpage_url": args.video_url or "",
        "tutorial_input_assets": [str(p) for p in learner],
    }
    if args.video_file:
        info["source_video_path"] = str(existing(args.video_file))
    if staged_asset:
        config = {
            "selected_model_relative": staged_asset.relative_to(linked).as_posix(),
            "selected_model": str(staged_asset),
            "selected_model_sha256": digest(staged_asset),
        }
        info["linked_source"] = config
        write_json(out / "linked_source.json", config)
        command(
            [
                options["blender"],
                "--background",
                "--factory-startup",
                "--disable-autoexec",
                "--python",
                str(HERE / "inspect_input_asset.py"),
                "--",
                "--asset",
                str(staged_asset),
                "--root",
                str(linked),
                "--output",
                str(out / "linked_asset_audit.json"),
            ],
            env,
            log=out / ".control/input_asset_inspection.log",
        )
        audit = json.loads((out / "linked_asset_audit.json").read_text())
        if audit.get("status") != "pass":
            raise ValueError(
                "Input asset has missing dependencies: " + "; ".join(audit["issues"])
            )
    if args.target_image:
        from PIL import Image

        Image.open(existing(args.target_image)).convert("RGB").save(
            out / "final_reference.png"
        )
    write_json(out / "source.info.json", info)
    return learner

def model_check(out: Path, env: dict, options: dict, provider: str) -> None:
    # The check uses the exact replay transport, not a separate undocumented API path.
    code = """import json, os, sys
from pathlib import Path
from video_replay_model_client import call_chat_completions, read_paid_api_secret
provider=os.environ['BLENDER_PIPELINE_PROVIDER']
r=call_chat_completions(video_dir=Path(sys.argv[1]),stage='codegen',stage_key='startup-check',prompt_version='startup-check-v1',endpoint=os.environ.get('BLENDER_PIPELINE_API_ENDPOINT',''),api_key=read_paid_api_secret(Path(os.environ['BLENDER_PIPELINE_API_KEY_FILE'])) if provider=='api' else '',model=os.environ['BLENDER_PIPELINE_MODEL'],payload={'model':os.environ['BLENDER_PIPELINE_MODEL'],'messages':[{'role':'user','content':'Reply exactly: PIPELINE_READY'}],'max_tokens':100,'reasoning_effort':'low'},timeout=(30,120))
if r.status_code >= 400: raise RuntimeError('Provider rejected startup check: HTTP '+str(r.status_code))
body=r.json(); answer=body['choices'][0]['message']['content']
if 'PIPELINE_READY' not in answer: raise RuntimeError('Unexpected startup response')
print(json.dumps({'provider':provider,'model':os.environ['BLENDER_PIPELINE_MODEL'],'response':'PIPELINE_READY'},ensure_ascii=False))
"""
    process_env = dict(env)
    process_env["PYTHONPATH"] = (
        str(GENERATION) + os.pathsep + process_env.get("PYTHONPATH", "")
    )
    command([sys.executable, "-c", code, str(out)], process_env)

def execute(provider: str, argv: list[str] | None) -> int:
    args = parser(provider).parse_args(argv)
    if args.configure:
        if args.dry_run:
            raise ValueError(
                "--configure cannot be combined with --dry-run; no configuration was written"
            )
        return configure(args, provider)
    if not args.output_dir:
        raise ValueError(
            "--output-dir is required; choose a data disk, not the repository"
        )
    if not args.check and not any((args.video_file, args.video_url, args.tutorial)):
        raise ValueError("Supply exactly one of --video-file, --video-url, --tutorial")
    for path in (
        args.video_file,
        args.tutorial,
        args.asset,
        args.target_image,
        args.transcript,
        *args.preview,
    ):
        if path:
            existing(path)
    if args.asset and args.asset.suffix.lower() not in MODEL_FORMATS:
        raise ValueError("--asset supports .blend, .glb, .gltf, .obj, .fbx")
    if args.asset_root and not args.asset:
        raise ValueError("--asset-root requires --asset")
    if args.asset_root:
        bundle = existing(args.asset_root, directory=True)
        if not existing(args.asset).is_relative_to(bundle):
            raise ValueError("--asset-root must contain --asset")
    for path in args.input_asset:
        resolved = path.expanduser().resolve(strict=True)
        if not (resolved.is_file() or resolved.is_dir()):
            raise ValueError("Supporting inputs must be regular files or directories")
    for path in (*args.preview, *([args.target_image] if args.target_image else [])):
        if path.suffix.lower() not in IMAGE_FORMATS:
            raise ValueError("Preview/target inputs must be supported image files")
    if args.tutorial and args.tutorial.suffix.lower() != ".md":
        raise ValueError(
            "--tutorial currently accepts Markdown (.md), not HTML/PDF/DOCX"
        )
    if args.video_url:
        video_url = urlparse(args.video_url)
        if (
            video_url.scheme != "https"
            or not video_url.netloc
            or video_url.username
            or video_url.password
        ):
            raise ValueError("Video URL must be a credential-free HTTPS URL")
    options = settings(args, provider)
    out = external(args.output_dir)
    if out.exists() and not out.is_dir():
        raise ValueError("--output-dir must name a directory, not an existing file")
    title = (
        args.title or (args.video_file or args.tutorial or Path("video_tutorial")).stem
    )
    plan = {
        "provider": provider,
        "model": options["model"],
        "tutorial_method": "provided" if args.tutorial else args.tutorial_method,
        "title": title,
        "output_dir": str(out),
        "input_project": str(args.asset) if args.asset else None,
        "supporting_inputs": [str(p) for p in args.input_asset],
        "input_previews": [str(p) for p in args.preview],
        "target_image": str(args.target_image) if args.target_image else None,
        "rw1_required": False,
        "knowledge_backend": "bundled reviewed guidance + run-local manifest_lexical",
        "stages": ["input staging", "tutorial preparation"]
        + (
            []
            if args.extract_only
            else [
                "knowledge retrieval",
                "existing strict Blender replay",
                "route-specific review",
            ]
        ),
        "extract_only": args.extract_only,
        "max_extraction_calls": args.max_extraction_calls,
        "max_replay_calls": args.max_replay_calls,
        "max_replay_tokens": args.max_replay_tokens,
    }
    if args.dry_run:
        print(json.dumps(plan, ensure_ascii=False, indent=2))
        return 0
    check_dependencies(args, options)
    if out.exists() and any(out.iterdir()):
        raise ValueError(
            "Output directory must be new/empty; previous results are never silently overwritten"
        )
    out.mkdir(parents=True, exist_ok=True)
    env = runtime_env(out, options, provider, args)
    write_json(out / "launch_manifest.json", plan)
    if args.check:
        model_check(out, env, options, provider)
        return 0
    learner = stage_inputs(args, out, title, env, options)
    if args.tutorial:
        from provided_tutorial import stage

        tutorial_manifest = stage(
            existing(args.tutorial), out, render_html=args.render_html
        )
        if (
            not args.extract_only
            and not args.target_image
            and not tutorial_manifest["images"]
        ):
            raise ValueError(
                "Full replay needs tutorial images or --target-image for visual comparison. "
                "An input-state --preview is not a finished-result reference. "
                "Use --extract-only to prepare a text-only tutorial without replay."
            )
    else:
        cmd = [
            sys.executable,
            str(EXTRACTION / "extract_video_tutorial.py"),
            "--video-file" if args.video_file else "--video-url",
            str(existing(args.video_file)) if args.video_file else args.video_url,
            "--title",
            title,
            "--output-dir",
            str(out),
            "--workspace-mode",
            "--provider",
            provider,
            "--model",
            options["model"],
            "--tutorial-method",
            args.tutorial_method,
            "--profile",
            args.profile,
            "--asr-language",
            args.asr_language,
            "--cache-dir",
            str(out.parent / ".video-tutorial-cache" / out.name),
        ]
        for item in learner:
            cmd.extend(["--input-asset", str(item)])
        if args.transcript:
            cmd.extend(["--transcript", str(existing(args.transcript))])
        if args.fallback_reason:
            cmd.extend(["--fallback-reason", args.fallback_reason])
        if args.max_extraction_calls is not None:
            cmd.extend(["--max-calls", str(args.max_extraction_calls)])
        if args.render_html:
            cmd.append("--render-html")
        command(cmd, env, log=out / ".control/tutorial_extraction.log")
    if args.extract_only:
        print(f"Tutorial ready: {out / 'tutorial.md'}")
        return 0
    command(
        [
            sys.executable,
            str(GENERATION / "build_blender_knowledge_index.py"),
            "--manifest-only",
        ],
        env,
        log=out / ".control/knowledge_index.log",
    )
    command(
        [
            sys.executable,
            str(GENERATION / "run_video_replay_main.py"),
            "--video-dir",
            str(out),
            "--out-name",
            "replay",
            "--skip-knowledge-update",
            "--workflow-evidence",
            "off",
        ],
        env,
        log=out / ".control/reproduction.log",
    )
    review = json.loads((out / "pipeline_review.json").read_text())
    if review.get("status") != "pass":
        print(
            f"Generated result needs review; it is not an accepted reproduction: {out / 'pipeline_review.json'}"
        )
        return 2
    print(f"Reproduction passed its current route checks: {out / 'asset.blend'}")
    return 0

def main(provider: str, argv: list[str] | None = None) -> int:
    try:
        return execute(provider, argv)
    except (
        ValueError,
        OSError,
        RuntimeError,
        ImportError,
        subprocess.TimeoutExpired,
    ) as exc:
        # Do not dump configuration, environment, or provider response bodies.
        print(f"Pipeline stopped: {exc}", file=sys.stderr)
        return 1
```

## File: skills/blender-pipeline/scripts/provided_tutorial.py
size: 11171
sha: 64f2ca28a7d5d4edb035ae1d6e2e3fe23863c8e7
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/scripts/provided_tutorial.py

```text
"""Source-preserving Markdown adapter; no model-invented steps or parameters."""

from __future__ import annotations

import base64
import hashlib
import json
import re
from pathlib import Path
from urllib.parse import unquote

SCHEMA = "video2blender-provided-tutorial.v1"
DESTINATION = r"(<[^>\n]+>|(?:\\.|[^()\s\\])+)"
TITLE = r"""("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))"""
IMAGE = re.compile(
    r"!\[([^\]\n]*)\]\(\s*" + DESTINATION + r"(?:[ \t]+" + TITLE + r")?[ \t]*\)"
)
REFERENCE = re.compile(r"!\[([^\]\n]*)\](?:\[([^\]\n]*)\])?")
DEFINITION = re.compile(
    r"^[ ]{0,3}\[([^\]\n]+)\]:[ \t]*"
    + DESTINATION
    + r"(?:[ \t]+"
    + TITLE
    + r")?[ \t]*$",
    re.M,
)
STEP = re.compile(
    r"^#{1,6}[ \t]+((?:步骤\s*|Step\s*)?\d+[.、:：)\s].*|步骤\s*\d+.*|Step\s*\d+.*)$",
    re.M | re.I,
)
ORDERED_ITEM = re.compile(r"^[0-9]{1,9}[.)][ \t]+[^\n]*$", re.M)
HEADING = re.compile(r"^#{1,6}[ \t]+[^\n]*$", re.M)
RICH_SECTION = re.compile(r"^##[ \t]+分段图文教程[ \t]*$", re.M)

def sha(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as stream:
        for block in iter(lambda: stream.read(1024 * 1024), b""):
            digest.update(block)
    return digest.hexdigest()

def markdown_mask(text: str) -> str:
    """Preserve offsets but hide code examples from heading/image discovery."""
    lines, fence = [], None
    for line in text.splitlines(keepends=True):
        marker = re.match(r"^ {0,3}(`{3,}|~{3,})", line)
        hidden = fence is not None or marker is not None
        if marker:
            value = marker[1]
            if fence is None:
                fence = value
            elif (
                value[0] == fence[0]
                and len(value) >= len(fence)
                and not line[marker.end() :].strip()
            ):
                fence = None
        lines.append(re.sub(r"[^\n]", " ", line) if hidden else line)
    masked = "".join(lines)
    return re.sub(r"(`+)([^\n]*?)\1", lambda m: " " * len(m[0]), masked)

def reference_key(value: str) -> str:
    return " ".join(value.split()).casefold()

def operation_spans(text: str) -> tuple[str, list[tuple[int, int]]]:
    """Project source operations without synthesizing headings or timestamps."""
    masked = markdown_mask(text)
    markers = list(STEP.finditer(masked))
    if markers:
        return "numbered_headings", [
            (m.start(), markers[i + 1].start() if i + 1 < len(markers) else len(text))
            for i, m in enumerate(markers)
        ]
    start, end = 0, len(text)
    rich = RICH_SECTION.search(masked)
    if rich:
        start = rich.end()
        boundary = re.compile(r"^#{1,2}[ \t]+", re.M).search(masked, start)
        if boundary:
            end = boundary.start()
    markers = [
        m
        for m in ORDERED_ITEM.finditer(masked, start, end)
        if re.sub(r"^[0-9]{1,9}[.)][ \t]+", "", text[m.start() : m.end()]).strip()
    ]
    spans = []
    for index, marker in enumerate(markers):
        stop = markers[index + 1].start() if index + 1 < len(markers) else end
        # A following window, contract or summary heading is not part of the
        # preceding numbered operation. Full context remains in tutorial.md.
        boundary = HEADING.search(masked, marker.end(), stop)
        if boundary:
            stop = boundary.start()
        spans.append((marker.start(), stop))
    return "rich_ordered_list" if rich else "top_level_ordered_list", spans

def stage(source: Path, workspace: Path, *, render_html: bool = False) -> dict:
    raw = source.read_text(encoding="utf-8-sig")
    masked = markdown_mask(raw)
    _step_format, spans = operation_spans(raw)
    if not spans:
        raise ValueError(
            "Markdown needs numbered operation headings or top-level ordered operation lists; "
            "legacy-rich lists under '## 分段图文教程' are supported."
        )
    if any(
        (workspace / name).exists()
        for name in (
            "tutorial.md",
            "tutorial_path_refs.md",
            "steps_verified.json",
            "tutorial_manifest.json",
            "provided_images",
        )
    ):
        raise ValueError(
            "Provided tutorial outputs already exist; use a new empty workspace"
        )
    if re.search(r"<img\b", masked, re.I):
        raise ValueError(
            "HTML image tags are not supported; use Markdown local/base64 images"
        )
    image_dir = workspace / "provided_images"
    records = []

    def copy_image(alt: str, raw_target: str, title: str = "") -> str:
        target = re.sub(
            r"\\([\\`*_{}\[\]()#+.!<> '\"])", r"\1", raw_target.strip().strip("<>")
        )
        if target.startswith("data:image/"):
            header, encoded = target.split(",", 1)
            if ";base64" not in header:
                raise ValueError("Only base64 data images are supported")
            content = base64.b64decode(encoded, validate=True)
            from PIL import Image
            import io

            picture = Image.open(io.BytesIO(content))
            suffix = {
                "PNG": ".png",
                "JPEG": ".jpg",
                "WEBP": ".webp",
                "GIF": ".gif",
                "TIFF": ".tif",
                "BMP": ".bmp",
            }.get(picture.format)
            if suffix is None:
                raise ValueError("Unsupported embedded image format")
            picture.verify()
        else:
            if "://" in target:
                raise ValueError(
                    "Download/authorize tutorial images yourself; Markdown images must be local or base64."
                )
            path = (source.parent / unquote(target)).resolve(strict=True)
            if not path.is_relative_to(source.parent.resolve()) or not path.is_file():
                raise ValueError(
                    "Tutorial image must be inside the tutorial's directory"
                )
            content = path.read_bytes()
            from PIL import Image
            import io

            Image.open(io.BytesIO(content)).verify()
            suffix = path.suffix.lower()
        image_dir.mkdir(exist_ok=True)
        name = hashlib.sha256(content).hexdigest() + suffix
        dest = image_dir / name
        dest.write_bytes(content)
        relative = dest.relative_to(workspace).as_posix()
        records.append({"path": relative, "sha256": sha(dest)})
        return f"![{alt}]({relative}{' ' + title if title else ''})"

    definitions = {
        reference_key(m[1]): (m[2], m[3] or "") for m in DEFINITION.finditer(masked)
    }
    replacements = []
    covered = []
    for match in IMAGE.finditer(masked):
        replacements.append(
            (match.start(), match.end(), copy_image(match[1], match[2], match[3] or ""))
        )
        covered.append((match.start(), match.end()))
    for match in REFERENCE.finditer(masked):
        if any(start <= match.start() < end for start, end in covered):
            continue
        key = reference_key(match[2] or match[1])
        if match.end() < len(masked) and masked[match.end()] == "(":
            raise ValueError(
                "Unsupported Markdown image destination; use <path with spaces> and an optional quoted title"
            )
        if key not in definitions:
            raise ValueError(
                "Unresolved Markdown image reference: " + (match[2] or match[1])
            )
        target, title = definitions[key]
        replacements.append(
            (match.start(), match.end(), copy_image(match[1], target, title))
        )
    text = raw
    for start, end, replacement in sorted(replacements, reverse=True):
        text = text[:start] + replacement + text[end:]
    step_format, spans = operation_spans(text)
    steps = []
    for i, (start, end) in enumerate(spans):
        action = text[start:end].strip()
        step = {
            "step_id": f"S{i + 1:03d}",
            "action": action,
            "object": "",
            "parameters": {},
            "source": "user_provided_tutorial",
            "verification_status": "user_supplied_not_independently_video_verified",
        }
        # The rich merger prints the exact source interval in the list prefix.
        # Preserve that string only when present; generic lists get no invented
        # video start/end times, parameters or verification claims.
        interval = re.match(
            r"^[0-9]{1,9}[.)][ \t]+`(\d{1,3}:\d{2}(?::\d{2})?(?:\.\d+)?"
            r"[ \t]*[-–—][ \t]*\d{1,3}:\d{2}(?::\d{2})?(?:\.\d+)?)`",
            action,
        )
        if interval:
            step["time_range"] = interval[1]
        steps.append(step)
    for name in ("tutorial.md", "tutorial_path_refs.md"):
        (workspace / name).write_text(text, encoding="utf-8")
    (workspace / "steps_verified.json").write_text(
        json.dumps(
            {
                "schema": SCHEMA,
                "authority": "user_provided_instructions",
                "verification_note": "Compatibility filename; this adapter does not claim video verification.",
                "steps": steps,
            },
            ensure_ascii=False,
            indent=2,
        ),
        encoding="utf-8",
    )
    manifest = {
        "schema": SCHEMA,
        "tutorial_method": "provided",
        "source_sha256": sha(source),
        "step_format": step_format,
        "counts": {"steps": len(steps)},
        "images": records,
        "files": [
            {"path": n, "sha256": sha(workspace / n)}
            for n in ("tutorial.md", "tutorial_path_refs.md", "steps_verified.json")
        ],
    }
    (workspace / "tutorial_manifest.json").write_text(
        json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8"
    )
    if render_html:
        import markdown

        body = markdown.markdown(text, extensions=["tables", "fenced_code"])
        (workspace / "illustrated_tutorial.html").write_text(
            "<!doctype html><meta charset=\"utf-8\"><meta http-equiv=\"Content-Security-Policy\" content=\"default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'\">"
            "<style>body{max-width:960px;margin:40px auto;font:17px/1.7 system-ui;padding:24px}img{max-width:100%}pre{overflow:auto}</style>"
            + body,
            encoding="utf-8",
        )
    return manifest

def validate_workspace(workspace: Path) -> list[str]:
    try:
        manifest = json.loads((workspace / "tutorial_manifest.json").read_text())
        issues = []
        for item in [*manifest["files"], *manifest["images"]]:
            path = (workspace / item["path"]).resolve()
            if (
                not path.is_relative_to(workspace.resolve())
                or not path.is_file()
                or sha(path) != item["sha256"]
            ):
                issues.append("Missing or changed source item: " + item["path"])
        if manifest["counts"]["steps"] < 1:
            issues.append("No ordered instructions")
        return issues
    except (ValueError, OSError, KeyError) as exc:
        return ["Invalid provided tutorial: " + str(exc)]
```

## File: skills/blender-pipeline/scripts/validate_package.py
size: 23705
sha: ba87181968db143fc3e5602e3da90a9cd85b3668
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/scripts/validate_package.py

```text
#!/usr/bin/env python3
"""Validate the standalone blender-pipeline skill without external packages."""

from __future__ import annotations

import argparse
import ast
import json
import re
import sys
from dataclasses import asdict, dataclass
from datetime import date
from pathlib import Path
from typing import Any, Callable, Iterable, Mapping, Sequence
from urllib.parse import unquote, urlsplit

DEFAULT_ROOT = Path(__file__).resolve().parents[1]
TEXT_SUFFIXES = {
    ".csv",
    ".html",
    ".json",
    ".md",
    ".py",
    ".sh",
    ".toml",
    ".txt",
    ".yaml",
    ".yml",
}
IGNORED_DIRS = {
    ".git",
    ".mypy_cache",
    ".pytest_cache",
    ".ruff_cache",
    ".venv",
    "__pycache__",
    "__MACOSX",
}
FORBIDDEN_ARTIFACT_SUFFIXES = {
    ".7z",
    ".avi",
    ".blend",
    ".blend1",
    ".bz2",
    ".db",
    ".fbx",
    ".gif",
    ".glb",
    ".gltf",
    ".gz",
    ".jpeg",
    ".jpg",
    ".log",
    ".m4v",
    ".mkv",
    ".mov",
    ".mp4",
    ".obj",
    ".png",
    ".rar",
    ".sqlite",
    ".stl",
    ".tar",
    ".tgz",
    ".usda",
    ".usdc",
    ".usd",
    ".webm",
    ".webp",
    ".xz",
    ".zip",
}
REQUIRED_FILES = {
    Path("SKILL.md"),
    Path("agents/openai.yaml"),
    Path("references/codex-launch.md"),
    Path("scripts/launch_from_codex.py"),
    Path("generation/SKILL.md"),
    Path("generation/requirements.txt"),
    Path("generation/requirements-knowledge.txt"),
    Path("editing/SKILL.md"),
    Path("editing/pyproject.toml"),
    Path("editing/schemas/assessment.schema.json"),
    Path("editing/schemas/edit_request.schema.json"),
    Path("editing/schemas/review_package.schema.json"),
    Path("editing/schemas/source_map.schema.json"),
    Path("editing/schemas/edit_receipt.schema.json"),
    Path("generation/scripts/render_illustrated_tutorial.py"),
    Path("generation/scripts/codex_cli_chat_bridge.py"),
    Path("generation/scripts/camera_framing.py"),
    Path("tutorial-extraction/SKILL.md"),
    Path("tutorial-extraction/agents/openai.yaml"),
    Path("tutorial-extraction/requirements.txt"),
    Path("tutorial-extraction/references/output-contract.md"),
    Path("tutorial-extraction/references/profiles-and-evidence.md"),
    Path("tutorial-extraction/schemas/manifest.schema.json"),
    Path("tutorial-extraction/schemas/steps.schema.json"),
    Path("tutorial-extraction/scripts/extract_video_tutorial.py"),
    Path("tutorial-extraction/scripts/visual_tutorial_pipeline.py"),
    Path("tutorial-extraction/scripts/legacy_rich_tutorial_pipeline.py"),
    Path("tutorial-extraction/scripts/prepare_video.py"),
    Path("tutorial-extraction/scripts/validate_visual_package.py"),
    Path("tutorial-extraction/references/evidence-ledger.md"),
    Path("tutorial-extraction/references/markdown-layout.md"),
    Path("tutorial-extraction/references/blender-capability-rubric.md"),
    Path("tutorial-extraction/scripts/tutorial_extraction_core.py"),
    Path("tutorial-extraction/scripts/validate_tutorial_package.py"),
    Path("tutorial-extraction/tests/test_visual_tutorial_pipeline.py"),
    Path("knowledge/index.md"),
    Path("knowledge/manifest.json"),
    Path("knowledge/manifest.schema.json"),
    Path("knowledge/evidence-and-routing.md"),
    Path("knowledge/generation.md"),
    Path("knowledge/editing.md"),
    Path("knowledge/rendering-and-dynamics.md"),
    Path("knowledge/operations-and-knowledge.md"),
    Path("scripts/validate_package.py"),
    Path("scripts/pipeline_launcher.py"),
    Path("scripts/provided_tutorial.py"),
    Path("scripts/inspect_input_asset.py"),
    Path("reproduction/SKILL.md"),
    Path("reproduction/references/execution-contract.md"),
    Path("reproduction/scripts/export_public_showcase_knowledge.py"),
    Path("reproduction/scripts/launch_video2blender_reproduction.py"),
    Path("reproduction/scripts/reproduce.sh"),
    Path("reproduction/scripts/validate_public_knowledge.py"),
    Path("reproduction/knowledge/manifest.json"),
    Path("reproduction/knowledge/public_media_attestations.json"),
    Path("reproduction/knowledge/public_showcase_inventory.json"),
}
REQUIRED_DIRS = {
    Path("generation/scripts"),
    Path("generation/tests"),
    Path("editing/src/blender_edit_pipeline"),
    Path("editing/tests"),
    Path("reproduction/tests"),
    Path("tutorial-extraction/tests"),
    Path("tests"),
}
LOCAL_IMPORT_PREFIXES = (
    "agent_",
    "blender_",
    "build_",
    "embed_",
    "extract_",
    "generate_",
    "merge_",
    "model_direct_",
    "prepare_",
    "project_paths",
    "render_",
    "retrieve_",
    "run_video_",
    "rw1_",
    "scan_",
    "update_",
    "video_replay_",
)
MARKDOWN_LINK = re.compile(r"!?\[[^\]]*\]\(([^)]+)\)")

@dataclass(frozen=True, order=True)
class Issue:
    check: str
    path: str
    message: str

def relative(path: Path, root: Path) -> str:
    try:
        return path.relative_to(root).as_posix()
    except ValueError:
        return path.as_posix()

def iter_files(root: Path, suffixes: set[str] | None = None) -> Iterable[Path]:
    for path in sorted(root.rglob("*")):
        if any(part in IGNORED_DIRS or part.startswith("._") for part in path.parts):
            continue
        if not path.is_file():
            continue
        if suffixes is not None and path.suffix.lower() not in suffixes:
            continue
        yield path

def read_text(path: Path) -> str:
    return path.read_text(encoding="utf-8")

def frontmatter(text: str) -> dict[str, str]:
    lines = text.splitlines()
    if len(lines) < 4 or lines[0].strip() != "---":
        return {}
    result: dict[str, str] = {}
    for line in lines[1:]:
        if line.strip() == "---":
            return result
        if ":" in line:
            key, value = line.split(":", 1)
            result[key.strip()] = value.strip().strip("\"'")
    return {}

def check_completeness(root: Path) -> list[Issue]:
    issues: list[Issue] = []
    for item in sorted(REQUIRED_FILES):
        if not (root / item).is_file():
            issues.append(
                Issue("completeness", item.as_posix(), "required file is missing")
            )
    for item in sorted(REQUIRED_DIRS):
        path = root / item
        if not path.is_dir() or not any(
            candidate.is_file() for candidate in path.rglob("*")
        ):
            issues.append(
                Issue(
                    "completeness",
                    item.as_posix(),
                    "required directory is empty or missing",
                )
            )

    for skill_path in (
        root / "SKILL.md",
        root / "generation/SKILL.md",
        root / "editing/SKILL.md",
        root / "reproduction/SKILL.md",
        root / "tutorial-extraction/SKILL.md",
    ):
        if not skill_path.is_file():
            continue
        metadata = frontmatter(read_text(skill_path))
        for key in ("name", "description"):
            if not metadata.get(key):
                issues.append(
                    Issue(
                        "completeness",
                        relative(skill_path, root),
                        f"frontmatter lacks {key}",
                    )
                )

    top_skill = root / "SKILL.md"
    if top_skill.is_file():
        top_text = read_text(top_skill)
        if len(top_text.splitlines()) > 80:
            issues.append(
                Issue(
                    "completeness",
                    "SKILL.md",
                    "router exceeds the 80-line disclosure budget",
                )
            )
        if frontmatter(top_text).get("name") != root.name:
            issues.append(
                Issue(
                    "completeness",
                    "SKILL.md",
                    "skill name must match the package directory",
                )
            )

    for path in iter_files(root):
        rel = relative(path, root)
        lowered = path.name.lower()
        if path.is_symlink():
            issues.append(
                Issue(
                    "completeness",
                    rel,
                    "symbolic links are not allowed in the standalone package",
                )
            )
        if lowered in {"readme.md", "changelog.md", "changes.md"}:
            issues.append(
                Issue(
                    "completeness",
                    rel,
                    "auxiliary documentation is outside the package contract",
                )
            )
        if path.suffix.lower() in FORBIDDEN_ARTIFACT_SUFFIXES:
            issues.append(
                Issue(
                    "completeness",
                    rel,
                    "generated or binary artifact is not package source",
                )
            )
        if path.stat().st_size > 2_000_000:
            issues.append(
                Issue("completeness", rel, "file exceeds the 2 MB source-package limit")
            )
    return issues

def _sensitive_patterns() -> Sequence[tuple[str, re.Pattern[str]]]:
    return (
        (
            "personal home path",
            re.compile(r"(?<![A-Za-z0-9_])/(?:Users|home)/[^/\s]+/"),
        ),
        ("mounted-volume path", re.compile(r"(?<![A-Za-z0-9_])/Volumes/")),
        ("internal share path", re.compile(r"(?<![A-Za-z0-9_])/F[0-9]{8,}/")),
        ("Windows user path", re.compile(r"[A-Za-z]:\\\\Users\\\\[^\\\s]+\\\\")),
        ("GitHub token", re.compile(r"gh[pousr]_[A-Za-z0-9]{20,}")),
        ("API secret", re.compile(r"sk-[A-Za-z0-9_-]{20,}")),
        ("cloud access key", re.compile(r"AKIA[0-9A-Z]{16}")),
        (
            "private key",
            re.compile(r"-----BEGIN (?:OPENSSH|RSA|EC|DSA) PRIVATE KEY-----"),
        ),
        ("private WeChat path", re.compile(r"xwechat_files", re.IGNORECASE)),
        ("embedded file URL", re.compile(r"file://", re.IGNORECASE)),
        ("embedded data URI", re.compile(r"data:(?:image|video)/", re.IGNORECASE)),
        ("credential in URL", re.compile(r"https?://[^/\s:@]+:[^/\s@]+@")),
    )

def check_sensitive_paths(root: Path) -> list[Issue]:
    issues: list[Issue] = []
    validator = (root / "scripts/validate_package.py").resolve()
    for path in iter_files(root, TEXT_SUFFIXES):
        if path.resolve() == validator:
            continue
        try:
            text = read_text(path)
        except UnicodeDecodeError:
            issues.append(
                Issue(
                    "sensitive", relative(path, root), "declared text file is not UTF-8"
                )
            )
            continue
        for label, pattern in _sensitive_patterns():
            if label == "embedded data URI" and path.suffix.lower() in {".py", ".sh"}:
                continue
            for match in pattern.finditer(text):
                line = text.count("\n", 0, match.start()) + 1
                issues.append(
                    Issue("sensitive", f"{relative(path, root)}:{line}", label)
                )
    return issues

def _module_exists(base: Path, parts: Sequence[str]) -> bool:
    if not parts:
        return True
    target = base.joinpath(*parts)
    return target.with_suffix(".py").is_file() or (target / "__init__.py").is_file()

def _import_names(node: ast.AST) -> Iterable[tuple[str, int]]:
    if isinstance(node, ast.Import):
        for alias in node.names:
            yield alias.name, 0
    elif isinstance(node, ast.ImportFrom):
        yield node.module or "", node.level

def _check_relative_import(path: Path, module: str, level: int) -> bool:
    base = path.parent
    for _ in range(max(0, level - 1)):
        base = base.parent
    return _module_exists(base, module.split(".") if module else ())

def check_imports(root: Path) -> list[Issue]:
    issues: list[Issue] = []
    generation_scripts = root / "generation/scripts"
    generation_modules = {
        path.stem
        for path in generation_scripts.glob("*.py")
        if path.name != "__init__.py"
    }
    editing_src = root / "editing/src"

    for path in iter_files(root, {".py"}):
        rel = relative(path, root)
        try:
            tree = ast.parse(read_text(path), filename=rel)
        except (SyntaxError, UnicodeDecodeError) as exc:
            issues.append(Issue("imports", rel, f"Python source does not parse: {exc}"))
            continue

        for node in ast.walk(tree):
            for module, level in _import_names(node):
                if level:
                    if not _check_relative_import(path, module, level):
                        issues.append(
                            Issue(
                                "imports",
                                f"{rel}:{getattr(node, 'lineno', 0)}",
                                f"unresolved relative import {'.' * level}{module}",
                            )
                        )
                    continue

                parts = module.split(".") if module else []
                top = parts[0] if parts else ""
                if top == "blender_edit_pipeline":
                    if not _module_exists(editing_src, parts):
                        issues.append(
                            Issue(
                                "imports",
                                f"{rel}:{getattr(node, 'lineno', 0)}",
                                f"unresolved editing import {module}",
                            )
                        )
                    continue

                in_generation = (
                    generation_scripts in path.parents
                    or root / "generation/tests" in path.parents
                )
                looks_local = top in generation_modules or top.startswith(
                    LOCAL_IMPORT_PREFIXES
                )
                if (
                    in_generation
                    and looks_local
                    and not _module_exists(generation_scripts, parts)
                ):
                    issues.append(
                        Issue(
                            "imports",
                            f"{rel}:{getattr(node, 'lineno', 0)}",
                            f"unresolved generation import {module}",
                        )
                    )
    return issues

def _json_type_matches(value: Any, expected: str) -> bool:
    mapping: Mapping[str, type | tuple[type, ...]] = {
        "array": list,
        "boolean": bool,
        "integer": int,
        "null": type(None),
        "number": (int, float),
        "object": dict,
        "string": str,
    }
    target = mapping.get(expected)
    if target is None:
        return False
    if expected in {"integer", "number"} and isinstance(value, bool):
        return False
    return isinstance(value, target)

def _validate_schema(
    value: Any, schema: Mapping[str, Any], location: str = "$"
) -> list[str]:
    errors: list[str] = []
    if "const" in schema and value != schema["const"]:
        errors.append(f"{location}: expected constant {schema['const']!r}")
    if "enum" in schema and value not in schema["enum"]:
        errors.append(f"{location}: value is outside the declared enum")
    expected_type = schema.get("type")
    if expected_type and not _json_type_matches(value, expected_type):
        errors.append(f"{location}: expected {expected_type}")
        return errors

    if isinstance(value, dict):
        required = schema.get("required", [])
        for key in required:
            if key not in value:
                errors.append(f"{location}: missing required property {key!r}")
        properties = schema.get("properties", {})
        if schema.get("additionalProperties") is False:
            for key in value:
                if key not in properties:
                    errors.append(f"{location}: undeclared property {key!r}")
        for key, child_schema in properties.items():
            if key in value:
                errors.extend(
                    _validate_schema(value[key], child_schema, f"{location}.{key}")
                )

    if isinstance(value, list):
        minimum = schema.get("minItems")
        if minimum is not None and len(value) < minimum:
            errors.append(f"{location}: requires at least {minimum} items")
        if schema.get("uniqueItems"):
            canonical = [
                json.dumps(item, ensure_ascii=False, sort_keys=True) for item in value
            ]
            if len(canonical) != len(set(canonical)):
                errors.append(f"{location}: items must be unique")
        item_schema = schema.get("items")
        if isinstance(item_schema, dict):
            for index, item in enumerate(value):
                errors.extend(
                    _validate_schema(item, item_schema, f"{location}[{index}]")
                )

    if isinstance(value, str):
        minimum = schema.get("minLength")
        if minimum is not None and len(value) < minimum:
            errors.append(f"{location}: requires at least {minimum} characters")
        pattern = schema.get("pattern")
        if pattern and re.search(pattern, value) is None:
            errors.append(f"{location}: does not match {pattern!r}")
        if schema.get("format") == "date":
            try:
                date.fromisoformat(value)
            except ValueError:
                errors.append(f"{location}: invalid ISO date")
    return errors

def check_json_schemas(root: Path) -> list[Issue]:
    issues: list[Issue] = []
    parsed: dict[Path, Any] = {}
    for path in iter_files(root, {".json"}):
        try:
            parsed[path] = json.loads(read_text(path))
        except (json.JSONDecodeError, UnicodeDecodeError) as exc:
            issues.append(
                Issue("json-schema", relative(path, root), f"invalid JSON: {exc}")
            )

    schema_path = root / "knowledge/manifest.schema.json"
    manifest_path = root / "knowledge/manifest.json"
    if schema_path not in parsed or manifest_path not in parsed:
        return issues
    schema = parsed[schema_path]
    manifest = parsed[manifest_path]
    if (
        not isinstance(schema, dict)
        or schema.get("$schema") != "https://json-schema.org/draft/2020-12/schema"
    ):
        issues.append(
            Issue(
                "json-schema",
                "knowledge/manifest.schema.json",
                "unsupported or missing schema dialect",
            )
        )
        return issues
    if not isinstance(manifest, dict):
        issues.append(
            Issue(
                "json-schema", "knowledge/manifest.json", "manifest must be an object"
            )
        )
        return issues
    for error in _validate_schema(manifest, schema):
        issues.append(Issue("json-schema", "knowledge/manifest.json", error))

    window = manifest.get("recent_extraction_window", {})
    if isinstance(window, dict):
        start = window.get("from")
        through = window.get("through")
        try:
            if date.fromisoformat(str(start)) > date.fromisoformat(str(through)):
                issues.append(
                    Issue(
                        "json-schema",
                        "knowledge/manifest.json",
                        "knowledge window is reversed",
                    )
                )
        except ValueError:
            pass
        if through != manifest.get("updated_through"):
            issues.append(
                Issue(
                    "json-schema",
                    "knowledge/manifest.json",
                    "updated_through differs from window through",
                )
            )

    declared_paths = [
        item.get("path")
        for item in manifest.get("documents", [])
        if isinstance(item, dict) and isinstance(item.get("path"), str)
    ]
    if len(declared_paths) != len(set(declared_paths)):
        issues.append(
            Issue(
                "json-schema",
                "knowledge/manifest.json",
                "document paths must be unique",
            )
        )
    declared = set(declared_paths)
    actual = {
        path.name
        for path in (root / "knowledge").glob("*.md")
        if not path.name.startswith("._")
    }
    if declared != actual:
        issues.append(
            Issue(
                "json-schema",
                "knowledge/manifest.json",
                f"declared Markdown differs from knowledge directory: declared={sorted(declared)}, actual={sorted(actual)}",
            )
        )
    return issues

def _markdown_target(raw: str) -> str:
    value = raw.strip()
    if value.startswith("<") and ">" in value:
        return value[1 : value.index(">")]
    return value.split(maxsplit=1)[0]

def check_links(root: Path) -> list[Issue]:
    issues: list[Issue] = []
    root_resolved = root.resolve()
    for path in iter_files(root, {".md"}):
        text = read_text(path)
        for match in MARKDOWN_LINK.finditer(text):
            target = unquote(_markdown_target(match.group(1)))
            parsed = urlsplit(target)
            if parsed.scheme or target.startswith("//"):
                continue
            local_part = parsed.path
            if not local_part:
                continue
            candidate = (path.parent / local_part).resolve()
            line = text.count("\n", 0, match.start()) + 1
            rel = f"{relative(path, root)}:{line}"
            if not candidate.is_relative_to(root_resolved):
                issues.append(
                    Issue("links", rel, f"local link escapes package root: {target}")
                )
            elif not candidate.exists():
                issues.append(Issue("links", rel, f"broken local link: {target}"))
    return issues

CHECKS: Mapping[str, Callable[[Path], list[Issue]]] = {
    "completeness": check_completeness,
    "sensitive": check_sensitive_paths,
    "imports": check_imports,
    "json-schema": check_json_schemas,
    "links": check_links,
}

def validate(root: Path, names: Sequence[str] | None = None) -> list[Issue]:
    selected = tuple(names or CHECKS)
    issues: list[Issue] = []
    for name in selected:
        issues.extend(CHECKS[name](root))
    return sorted(set(issues))

def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--root", type=Path, default=DEFAULT_ROOT, help="blender-pipeline skill root"
    )
    parser.add_argument(
        "--check",
        action="append",
        choices=sorted(CHECKS),
        dest="checks",
        help="run only one named check; repeat as needed",
    )
    parser.add_argument(
        "--json", action="store_true", help="emit a machine-readable report"
    )
    return parser

def main(argv: Sequence[str] | None = None) -> int:
    args = build_parser().parse_args(argv)
    root = args.root.resolve()
    issues = validate(root, args.checks)
    if args.json:
        print(
            json.dumps(
                {
                    "root": str(root),
                    "status": "fail" if issues else "pass",
                    "issues": [asdict(issue) for issue in issues],
                },
                ensure_ascii=False,
                indent=2,
                sort_keys=True,
            )
        )
    elif issues:
        for issue in issues:
            print(f"{issue.check}: {issue.path}: {issue.message}", file=sys.stderr)
        print(f"FAIL: {len(issues)} package issue(s)", file=sys.stderr)
    else:
        selected = ", ".join(args.checks or CHECKS)
        print(f"PASS: blender-pipeline package ({selected})")
    return 1 if issues else 0

if __name__ == "__main__":
    raise SystemExit(main())
```

## File: skills/blender-pipeline/references/codex-launch.md
size: 7488
sha: 5feeaaf59213d82862ce5a3d64f4149760add2a2
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/references/codex-launch.md

````text
# Codex conversation launcher

## Interpret the request

The interaction is: select `$blender-pipeline`, then provide the video/tutorial
and any supporting files in normal language. Codex constructs and runs the
command. Do not ask the user to translate their request into CLI arguments.
If the skill is selected without any task input, ask for the video URL/file or
Markdown tutorial. Honor requests to explain or preview without execution.

Resolve the intended output before starting downloads, model calls or Blender:

| Input | Tutorial-only workflow | Reconstruction workflow |
| --- | --- | --- |
| Video URL or local video | Extract illustrated Markdown; optional HTML | Extract → retrieve knowledge → reconstruct → render |
| Video with starter project / supporting files | Extract with the supplied learner inputs | Preserve the starter and use its dependencies during reconstruction |
| Markdown tutorial, optionally with assets | Prepare existing Markdown/images; optional HTML, no video extraction | Skip extraction → retrieve knowledge → reconstruct → render |

If a video is supplied without an explicit goal, ask: “你希望只生成图文教程，还是继续复现视频中的 Blender 作品？”
For Markdown, ask: “你希望整理这份图文教程，还是按教程生成 Blender 作品？”
Use the user's language. A clear request such as “只要教程”, “转 HTML”, or
“复现并生成 .blend” already answers this question; do not ask again or treat
the Skill's generic selection prompt as authorization for reconstruction.
Wait for the answer; combine genuinely missing source/output questions when
possible. Follow the user's latest choice, not a default inferred from input type.

Accept multiple independent video links in one message. Run them sequentially,
with one `--video-url` per helper invocation and a separate subject/BVID-named
child directory under the selected output root. Ask about the goal once for
the batch, not once per video; preserve any explicitly different per-video goals
and supporting inputs. Do not pass a list or repeat `--video-url` in one call.
If the user intends several videos to contribute to a single asset, clarify
that separate runs do not merge tutorials instead of silently discarding links.

Select one primary source and preserve each attachment's actual role:

| Supplied input | Internal argument |
| --- | --- |
| Video link | `--video-url` |
| Local video file | `--video-file` |
| Existing Markdown tutorial | `--tutorial` |
| Starting `.blend`, `.glb`, `.gltf`, `.obj`, or `.fbx` | `--asset` |
| Complete dependency directory containing that model | `--asset-root` |
| Texture or other learner resource | repeat `--input-asset` |
| Starting-asset preview | repeat `--preview` |
| Finished-result reference | `--target-image` |
| Timestamped transcript | `--transcript` |

A video plus a starter project stays within the selected workflow, not a separate edit.
Markdown may also include a starter project or textures. Retain the tutorial's
relative images and the model's dependency structure. Do not use a starting
preview as a texture or final target. If an image's role or the primary source
is genuinely ambiguous, ask one concise question before launching. A text-only
Markdown replay needs a finished-result image; ask for it when absent. Do not
silently convert a full replay into extraction-only to avoid missing input.

## Resolve the run location

Use the output directory explicitly requested by the user. Otherwise select a
new subject-named run directory beneath the user's established data root from
the conversation or `BLENDER_PIPELINE_OUTPUT_ROOT`. Add a timestamp when needed
to avoid overwriting an earlier run. If no data location is established, ask
once where to save the result. Respect external-disk requirements; never
silently fall back to the system disk if that location is unavailable.

Resolve the current skill directory from this `SKILL.md` location, following
symlinks, rather than assuming the shell's working directory is the repository.
Resolve supplied relative file paths against the user's workspace before
invoking the helper. Quote each path as one argument, including spaces and
non-ASCII names. Do not write inputs or results into the installed skill/repo.

## Launch and finish

1. After resolving the goal, briefly state the selected workflow, mapped inputs
   and output location, then execute without another confirmation round.
2. Invoke `scripts/launch_from_codex.py` under the resolved skill directory with
   the selected source, output directory and supporting arguments. For example,
   the following are internal invocations performed by Codex, not instructions
   to hand back to the user:

   ```text
   python3 "<skill-dir>/scripts/launch_from_codex.py" --video-url "<url>" --extract-only --render-html --output-dir "<new-run-dir>"
   python3 "<skill-dir>/scripts/launch_from_codex.py" --video-url "<url>" --output-dir "<new-run-dir>"
   python3 "<skill-dir>/scripts/launch_from_codex.py" --video-file "<video>" --asset "<starter.blend>" --preview "<before.png>" --output-dir "<new-run-dir>"
   python3 "<skill-dir>/scripts/launch_from_codex.py" --tutorial "<tutorial.md>" --output-dir "<new-run-dir>"
   ```

   Prefer the repository's `.venv/bin/python` (`.venv/Scripts/python.exe` on
   Windows) created during setup; otherwise use a compatible configured Python.
   The helper uses the signed-in Codex CLI for model calls. Do not ask for an
   API key or switch to API mode. Forward a user-supplied Blender executable as `--blender`.
   Missing Blender, FFmpeg, Python dependencies, or Codex login should be
   reported specifically; do not install large packages or launch a different
   workflow without user direction. Retain `gpt-5.6-sol` and the existing bounded
   call/repair settings; use `gpt-5.5` only through the supported explicit fallback.
3. Map tutorial-only to `--extract-only`, and reconstruction to no such flag.
   `--check` and `--dry-run` are only for an explicit request for those operations.
   Use `visual` extraction by default (recommended for videos up to ten minutes);
   an explicit original rich/base64 request maps to `--tutorial-method legacy-rich`.
   Add `--render-html` only when requested. For an explicit rendering choice,
   set `VIDEO2BLENDER_CYCLES_BACKEND` for this invocation: `CPU`, `METAL` (Apple),
   `OPTIX`/`CUDA` (NVIDIA), `HIP` (AMD), or `ONEAPI` (Intel), as supported locally.
   Otherwise preserve the configured backend (default CPU); do not guess a GPU.
4. Let the helper manage extraction, knowledge lookup, scene generation and
   review. Do not run those stages a second time manually. Follow a running
   process until it finishes or needs input; do not return only its process ID.
   Do not automatically restart an entire paid run after an unclear failure.
5. For tutorial-only, read the exit status and link the produced `tutorial.md`,
   its local images, and requested HTML. Do not require `pipeline_review.json`
   or claim a Blender result. For reconstruction, read the exit status and
   `pipeline_review.json`; link the `.blend`, render, tutorial and any animation.
   Report a stopped stage or a result needing review as such, not full completion.

API use remains available separately through the unchanged API launcher. Do not
commit, push, publish results, or promote knowledge as a side effect of a Skill
launch unless the user separately requests it.
````

## File: skills/blender-pipeline/agents/openai.yaml
size: 300
sha: 263f90302676a8004f2162301009bf6b18e6acb0
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/agents/openai.yaml

```text
interface:
  display_name: "Blender Pipeline"
  short_description: "Create a tutorial or reconstruct a Blender result from video"
  default_prompt: "使用 $blender-pipeline 处理我提供的视频、配套资产或 Markdown 图文教程；如果我没有说明需要哪种结果，请先询问。"
```

## File: skills/blender-pipeline/editing/pyproject.toml
size: 576
sha: 1b6c697c0bfb23097ac08e86692d3560e6589b4c
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/pyproject.toml

```text
[build-system]
requires = ["setuptools>=68"]
build-backend = "setuptools.build_meta"

[project]
name = "blender-edit-pipeline"
version = "0.1.0"
description = "Contract-driven, scope-preserving edits of existing Blender projects"
readme = {file = "SKILL.md", content-type = "text/markdown"}
requires-python = ">=3.10"
dependencies = []

[project.optional-dependencies]
test = ["jsonschema>=4.21,<5"]

[project.scripts]
blender-edit-pipeline = "blender_edit_pipeline.pipeline:main"

[tool.setuptools]
package-dir = {"" = "src"}

[tool.setuptools.packages.find]
where = ["src"]
```

## File: skills/blender-pipeline/editing/schemas/assessment.schema.json
size: 1573
sha: 8f1f3a17f14da4bad2185a2efacc6ec4482a4f52
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/schemas/assessment.schema.json

```text
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://freedomintelligence.github.io/3D-Coding-Blender/schemas/blender-edit-assessment-v1.json",
  "title": "External Blender edit visual assessment",
  "type": "object",
  "additionalProperties": false,
  "required": ["schema", "decision", "review_package_sha256", "bindings", "assessor", "scores", "summary"],
  "properties": {
    "schema": {"const": "blender-edit-assessment/v1"},
    "decision": {"const": "accepted"},
    "review_package_sha256": {"$ref": "#/$defs/digest"},
    "bindings": {
      "type": "object", "additionalProperties": false,
      "required": ["candidate_sha256", "before_sha256", "after_sha256"],
      "properties": {
        "candidate_sha256": {"$ref": "#/$defs/digest"},
        "before_sha256": {"$ref": "#/$defs/digest"},
        "after_sha256": {"$ref": "#/$defs/digest"}
      }
    },
    "assessor": {
      "type": "object", "additionalProperties": false, "required": ["kind", "name"],
      "properties": {
        "kind": {"enum": ["human", "vlm"]},
        "name": {"type": "string", "minLength": 1, "maxLength": 256}
      }
    },
    "scores": {
      "type": "object", "additionalProperties": false, "required": ["before", "after"],
      "properties": {
        "before": {"type": "number", "minimum": 0, "maximum": 100},
        "after": {"type": "number", "minimum": 0, "maximum": 100}
      }
    },
    "summary": {"type": "string", "minLength": 1, "maxLength": 2000}
  },
  "$defs": {"digest": {"type": "string", "pattern": "^[0-9a-f]{64}$"}}
}
```

## File: skills/blender-pipeline/editing/schemas/edit_receipt.schema.json
size: 3632
sha: 835919a19cf983b0bc04a386123d5c6bf31c3007
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/schemas/edit_receipt.schema.json

```text
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://freedomintelligence.github.io/3D-Coding-Blender/schemas/blender-edit-receipt-v1.json",
  "title": "Completed Blender edit receipt",
  "type": "object",
  "additionalProperties": false,
  "required": ["schema", "status", "edit_id", "kind", "source", "request_sha256", "targets", "changes", "non_target_drift", "reopen", "review", "visual_evidence", "artifacts"],
  "properties": {
    "schema": {"const": "blender-edit-receipt/v1"}, "status": {"const": "complete"},
    "edit_id": {"type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$"},
    "kind": {"enum": ["material", "color", "geometry", "modeling", "scene"]},
    "source": {
      "type": "object", "additionalProperties": false, "required": ["filename", "sha256"],
      "properties": {"filename": {"type": "string"}, "sha256": {"$ref": "#/$defs/digest"}}
    },
    "request_sha256": {"$ref": "#/$defs/digest"},
    "targets": {"type": "object"}, "changes": {"type": "object"},
    "non_target_drift": {"type": "array", "maxItems": 0},
    "reopen": {
      "type": "object", "additionalProperties": false, "required": ["verified", "snapshot_digest"],
      "properties": {"verified": {"const": true}, "snapshot_digest": {"$ref": "#/$defs/digest"}}
    },
    "review": {
      "type": "object", "additionalProperties": false,
      "required": ["package_sha256", "assessment_sha256"],
      "properties": {
        "package_sha256": {"$ref": "#/$defs/digest"},
        "assessment_sha256": {"$ref": "#/$defs/digest"}
      }
    },
    "visual_evidence": {
      "type": "object", "additionalProperties": false,
      "required": ["before", "after", "difference", "assessment"],
      "properties": {
        "before": {"$ref": "#/$defs/artifact"},
        "after": {"$ref": "#/$defs/artifact"},
        "difference": {"$ref": "#/$defs/difference"},
        "assessment": {
          "type": "object", "additionalProperties": false,
          "required": ["kind", "name", "before_score", "after_score", "minimum_after_score", "summary", "sha256"],
          "properties": {
            "kind": {"enum": ["human", "vlm"]}, "name": {"type": "string", "minLength": 1},
            "before_score": {"type": "number", "minimum": 0, "maximum": 100},
            "after_score": {"type": "number", "minimum": 80, "maximum": 100},
            "minimum_after_score": {"type": "number", "minimum": 80, "maximum": 100},
            "summary": {"type": "string", "minLength": 1, "maxLength": 2000},
            "sha256": {"$ref": "#/$defs/digest"}
          }
        }
      }
    },
    "artifacts": {"type": "array", "minItems": 6, "maxItems": 6, "items": {"$ref": "#/$defs/artifact"}}
  },
  "$defs": {
    "digest": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
    "artifact": {
      "type": "object", "additionalProperties": false, "required": ["path", "sha256", "bytes"],
      "properties": {
        "path": {"enum": ["asset.blend", "before.png", "after.png", "source_map.json", "review_package.json", "assessment.json"]}, "sha256": {"$ref": "#/$defs/digest"},
        "bytes": {"type": "integer", "minimum": 1}
      }
    },
    "difference": {
      "type": "object", "additionalProperties": false,
      "required": ["width", "height", "changed_fraction", "mean_absolute_delta"],
      "properties": {
        "width": {"type": "integer", "minimum": 1}, "height": {"type": "integer", "minimum": 1},
        "changed_fraction": {"type": "number", "minimum": 0, "maximum": 1},
        "mean_absolute_delta": {"type": "number", "minimum": 0, "maximum": 255}
      }
    }
  }
}
```

## File: skills/blender-pipeline/editing/schemas/edit_request.schema.json
size: 11361
sha: fb8632ec1eb7aebfed05d1107270a353c407cd46
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/schemas/edit_request.schema.json

```text
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://freedomintelligence.github.io/3D-Coding-Blender/schemas/blender-edit-request-v1.json",
  "title": "Blender edit request",
  "type": "object",
  "additionalProperties": false,
  "required": ["schema", "edit_id", "kind", "source_blend", "source_sha256", "targets", "parameters"],
  "properties": {
    "schema": {"const": "blender-edit-request/v1"},
    "edit_id": {"type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$"},
    "kind": {"enum": ["material", "color", "geometry", "modeling", "scene"]},
    "source_blend": {"type": "string", "minLength": 1},
    "source_sha256": {"$ref": "#/$defs/digest"},
    "targets": {"$ref": "#/$defs/targets"},
    "parameters": {"type": "object", "minProperties": 1},
    "evidence": {"$ref": "#/$defs/evidence"}
  },
  "allOf": [
    {
      "if": {"properties": {"kind": {"const": "material"}}},
      "then": {"properties": {
        "targets": {"required": ["materials"], "propertyNames": {"const": "materials"}},
        "parameters": {"$ref": "#/$defs/material_parameters"}
      }}
    },
    {
      "if": {"properties": {"kind": {"const": "color"}}},
      "then": {"properties": {
        "targets": {"required": ["materials"], "propertyNames": {"const": "materials"}},
        "parameters": {"$ref": "#/$defs/color_parameters"}
      }}
    },
    {
      "if": {"properties": {"kind": {"const": "geometry"}}},
      "then": {"properties": {
        "targets": {"required": ["objects"], "propertyNames": {"const": "objects"}},
        "parameters": {"$ref": "#/$defs/geometry_parameters"}
      }}
    },
    {
      "if": {"properties": {"kind": {"const": "modeling"}}},
      "then": {"properties": {
        "targets": {
          "propertyNames": {"enum": ["objects", "generated_objects"]},
          "anyOf": [{"required": ["objects"]}, {"required": ["generated_objects"]}]
        },
        "parameters": {"$ref": "#/$defs/modeling_parameters"}
      }}
    },
    {
      "if": {"properties": {"kind": {"const": "scene"}}},
      "then": {"properties": {
        "targets": {"propertyNames": {"enum": ["lights", "camera"]}},
        "parameters": {"$ref": "#/$defs/scene_parameters"}
      }}
    }
  ],
  "$defs": {
    "digest": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
    "number": {"type": "number"},
    "unit_number": {"type": "number", "minimum": 0, "maximum": 1},
    "vec2": {"type": "array", "items": {"$ref": "#/$defs/number"}, "minItems": 2, "maxItems": 2},
    "vec3": {"type": "array", "items": {"$ref": "#/$defs/number"}, "minItems": 3, "maxItems": 3},
    "color3": {"type": "array", "items": {"$ref": "#/$defs/unit_number"}, "minItems": 3, "maxItems": 3},
    "color": {"type": "array", "items": {"$ref": "#/$defs/unit_number"}, "minItems": 3, "maxItems": 4},
    "names": {"type": "array", "items": {"type": "string", "minLength": 1}, "minItems": 1, "uniqueItems": true},
    "targets": {
      "type": "object", "additionalProperties": false,
      "properties": {
        "objects": {"$ref": "#/$defs/names"}, "materials": {"$ref": "#/$defs/names"},
        "lights": {"$ref": "#/$defs/names"}, "camera": {"$ref": "#/$defs/names"},
        "generated_objects": {"$ref": "#/$defs/names"}
      }
    },
    "principled_inputs": {
      "type": "object", "additionalProperties": false, "minProperties": 1,
      "properties": {
        "Base Color": {"$ref": "#/$defs/color"}, "Emission Color": {"$ref": "#/$defs/color"},
        "Metallic": {"$ref": "#/$defs/unit_number"}, "Roughness": {"$ref": "#/$defs/unit_number"},
        "IOR": {"type": "number", "minimum": 1, "maximum": 4}, "Alpha": {"$ref": "#/$defs/unit_number"},
        "Transmission Weight": {"$ref": "#/$defs/unit_number"}, "Coat Weight": {"$ref": "#/$defs/unit_number"},
        "Coat Roughness": {"$ref": "#/$defs/unit_number"}
      }
    },
    "material_parameters": {
      "type": "object", "additionalProperties": false, "required": ["materials"],
      "properties": {"materials": {"type": "object", "minProperties": 1, "additionalProperties": {"$ref": "#/$defs/principled_inputs"}}}
    },
    "hue_adjustment": {
      "type": "object", "additionalProperties": false, "minProperties": 1,
      "properties": {
        "hue": {"type": "number", "minimum": 0, "maximum": 1},
        "saturation": {"type": "number", "minimum": 0, "maximum": 2},
        "value": {"type": "number", "minimum": 0, "maximum": 2},
        "factor": {"$ref": "#/$defs/unit_number"}
      }
    },
    "color_parameters": {
      "oneOf": [
        {
          "type": "object", "additionalProperties": false, "required": ["colors"],
          "properties": {"colors": {"type": "object", "minProperties": 1, "additionalProperties": {"$ref": "#/$defs/color"}}}
        },
        {
          "type": "object", "additionalProperties": false, "required": ["hue_saturation"],
          "properties": {"hue_saturation": {"type": "object", "minProperties": 1, "additionalProperties": {"$ref": "#/$defs/hue_adjustment"}}}
        }
      ]
    },
    "face": {"type": "array", "items": {"type": "integer", "minimum": 0}, "minItems": 3, "uniqueItems": true},
    "uv_layers": {
      "type": "object", "minProperties": 1,
      "additionalProperties": {"type": "array", "items": {"$ref": "#/$defs/vec2"}}
    },
    "geometry_inline_replacement": {
      "type": "object", "additionalProperties": false, "required": ["vertices", "faces"],
      "properties": {
        "vertices": {"type": "array", "items": {"$ref": "#/$defs/vec3"}, "minItems": 4},
        "faces": {"type": "array", "items": {"$ref": "#/$defs/face"}, "minItems": 1},
        "uv_layers": {"$ref": "#/$defs/uv_layers"}, "fit_to_source_bbox": {"type": "boolean"},
        "envelope_tolerance": {"type": "number", "minimum": 0, "maximum": 1},
        "volume_ratio_tolerance": {"type": "number", "minimum": 0, "maximum": 1},
        "world_center_tolerance": {"type": "number", "minimum": 0, "maximum": 100000}
      }
    },
    "geometry_generation_handoff": {
      "type": "object", "additionalProperties": false,
      "required": ["attempt_receipt", "attempt_receipt_sha256", "asset_blend", "asset_blend_sha256", "object"],
      "properties": {
        "attempt_receipt": {"type": "string", "minLength": 1},
        "attempt_receipt_sha256": {"$ref": "#/$defs/digest"},
        "asset_blend": {"type": "string", "minLength": 1},
        "asset_blend_sha256": {"$ref": "#/$defs/digest"},
        "object": {"type": "string", "minLength": 1},
        "fit_to_source_bbox": {"type": "boolean"},
        "envelope_tolerance": {"type": "number", "minimum": 0, "maximum": 1},
        "volume_ratio_tolerance": {"type": "number", "minimum": 0, "maximum": 1},
        "world_center_tolerance": {"type": "number", "minimum": 0, "maximum": 100000}
      }
    },
    "geometry_parameters": {
      "type": "object", "additionalProperties": false, "required": ["replacements"],
      "properties": {
        "replacements": {
          "type": "object", "minProperties": 1,
          "additionalProperties": {
            "oneOf": [
              {"$ref": "#/$defs/geometry_inline_replacement"},
              {"$ref": "#/$defs/geometry_generation_handoff"}
            ]
          }
        }
      }
    },
    "add_primitive": {
      "type": "object", "additionalProperties": false, "required": ["op", "name", "primitive", "collection"],
      "properties": {
        "op": {"const": "add_primitive"}, "name": {"type": "string", "minLength": 1},
        "primitive": {"enum": ["cube", "uv_sphere", "cylinder", "cone", "torus"]},
        "collection": {"type": "string", "minLength": 1}, "location": {"$ref": "#/$defs/vec3"},
        "rotation": {"$ref": "#/$defs/vec3"}, "scale": {"$ref": "#/$defs/vec3"}
      }
    },
    "modifier_settings": {
      "type": "object", "additionalProperties": false,
      "properties": {
        "width": {"type": "number", "minimum": 0, "maximum": 100000},
        "segments": {"type": "integer", "minimum": 1, "maximum": 64},
        "thickness": {"type": "number", "minimum": -100000, "maximum": 100000},
        "offset": {"type": "number", "minimum": -1, "maximum": 1},
        "levels": {"type": "integer", "minimum": 0, "maximum": 6},
        "render_levels": {"type": "integer", "minimum": 0, "maximum": 6}
      }
    },
    "add_modifier": {
      "type": "object", "additionalProperties": false, "required": ["op", "object", "modifier_type"],
      "properties": {
        "op": {"const": "add_modifier"}, "object": {"type": "string", "minLength": 1},
        "modifier_type": {"enum": ["BEVEL", "SOLIDIFY", "SUBSURF"]},
        "name": {"type": "string", "minLength": 1}, "settings": {"$ref": "#/$defs/modifier_settings"}
      }
    },
    "modeling_parameters": {
      "type": "object", "additionalProperties": false, "required": ["operations"],
      "properties": {
        "operations": {"type": "array", "minItems": 1, "items": {"oneOf": [{"$ref": "#/$defs/add_primitive"}, {"$ref": "#/$defs/add_modifier"}]}}
      }
    },
    "light_edit": {
      "type": "object", "additionalProperties": false, "minProperties": 1,
      "properties": {
        "energy": {"type": "number", "minimum": 0, "maximum": 1000000},
        "energy_multiplier": {"type": "number", "minimum": 0, "maximum": 100},
        "color": {"$ref": "#/$defs/color3"}, "shadow_soft_size": {"type": "number", "minimum": 0, "maximum": 1000}
      },
      "not": {"required": ["energy", "energy_multiplier"]}
    },
    "camera_edit": {
      "type": "object", "additionalProperties": false, "minProperties": 1,
      "properties": {
        "location": {"$ref": "#/$defs/vec3"}, "rotation": {"$ref": "#/$defs/vec3"},
        "lens": {"type": "number", "minimum": 1, "maximum": 1000}
      }
    },
    "scene_parameters": {
      "type": "object", "additionalProperties": false, "minProperties": 1,
      "properties": {
        "lights": {"type": "object", "additionalProperties": {"$ref": "#/$defs/light_edit"}},
        "cameras": {"type": "object", "additionalProperties": {"$ref": "#/$defs/camera_edit"}},
        "allow_world": {"type": "boolean"}, "world_color": {"$ref": "#/$defs/color3"},
        "allow_exposure": {"type": "boolean"}, "exposure": {"type": "number", "minimum": -32, "maximum": 32}
      },
      "allOf": [
        {"if": {"required": ["allow_world"], "properties": {"allow_world": {"const": true}}}, "then": {"required": ["world_color"]}},
        {"if": {"required": ["world_color"]}, "then": {"required": ["allow_world"], "properties": {"allow_world": {"const": true}}}},
        {"if": {"required": ["allow_exposure"], "properties": {"allow_exposure": {"const": true}}}, "then": {"required": ["exposure"]}},
        {"if": {"required": ["exposure"]}, "then": {"required": ["allow_exposure"], "properties": {"allow_exposure": {"const": true}}}}
      ]
    },
    "evidence": {
      "type": "object", "additionalProperties": false,
      "properties": {
        "render": {"const": true}, "resolution": {"type": "integer", "minimum": 32, "maximum": 4096},
        "min_changed_fraction": {"type": "number", "minimum": 0, "maximum": 1},
        "min_mean_absolute_delta": {"type": "number", "minimum": 0, "maximum": 255},
        "minimum_after_score": {"type": "number", "minimum": 80, "maximum": 100}
      }
    }
  }
}
```

## File: skills/blender-pipeline/editing/schemas/review_package.schema.json
size: 2490
sha: 7971a4dd55bf6af310cc3822621a114fd552547f
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/schemas/review_package.schema.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/schemas/review_package.schema.json

## File: skills/blender-pipeline/editing/schemas/source_map.schema.json
size: 2635
sha: da389f6649a2e0f778d837884b9c1063a56a0be9
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/schemas/source_map.schema.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/schemas/source_map.schema.json

## File: skills/blender-pipeline/editing/src/blender_edit_pipeline/__init__.py
size: 241
sha: 83a9c021c63fed4b85899ee8704cbc3b0be7f37a
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/__init__.py

```text
"""Public contracts for the Blender existing-asset editing pipeline."""

from .contracts import ContractError, EditKind, EditRequest, load_request

__all__ = ["ContractError", "EditKind", "EditRequest", "load_request"]
__version__ = "0.1.0"
```

## File: skills/blender-pipeline/editing/src/blender_edit_pipeline/contracts.py
size: 11325
sha: 4705bff079cc167485d6970745ab4658f8188ca0
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/contracts.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/contracts.py

## File: skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/__init__.py
size: 680
sha: 57570145d28de6e7d1bcf4be5d7a4bf926d6ce6c
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/__init__.py

```text
"""Allowlisted edit operator dispatch."""

from __future__ import annotations

from typing import Any

from ..contracts import EditKind, EditRequest
from .geometry import apply_geometry, apply_modeling
from .material import apply_color, apply_material
from .scene import apply_scene

def apply_edit(request: EditRequest, bpy_module: Any | None = None) -> dict[str, Any]:
    dispatch = {
        EditKind.MATERIAL: apply_material,
        EditKind.COLOR: apply_color,
        EditKind.GEOMETRY: apply_geometry,
        EditKind.MODELING: apply_modeling,
        EditKind.SCENE: apply_scene,
    }
    return dispatch[request.kind](request, bpy_module)

__all__ = ["apply_edit"]
```

## File: skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/geometry.py
size: 37533
sha: 1b09a817770e78ce2aca13641e7594c81f0a5900
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/geometry.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/geometry.py

## File: skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/material.py
size: 6631
sha: e9df2726be36d617da6874728f8370c94fea5a12
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/material.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/material.py

## File: skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/scene.py
size: 7275
sha: d261989d67e5cfa592045a2f9f954b1acccb734c
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/scene.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/scene.py

## File: skills/blender-pipeline/editing/src/blender_edit_pipeline/pipeline.py
size: 22747
sha: 31a3ea806b7c0a932955bb1ee388228cd849f1ab
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/pipeline.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/pipeline.py

## File: skills/blender-pipeline/editing/src/blender_edit_pipeline/qa.py
size: 29062
sha: 8457cfaf84a56aabd9b5ea7d2bd5507a9ce15e76
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/qa.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/qa.py

## File: skills/blender-pipeline/editing/src/blender_edit_pipeline/source_preflight.py
size: 7155
sha: 40eb4ce57989ff718d51522927aee4c0a4386424
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/source_preflight.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/src/blender_edit_pipeline/source_preflight.py

## File: skills/blender-pipeline/editing/tests/test_blender_e2e.py
size: 17671
sha: 24828babc34dbffb6338e9de3191e98863769a3c
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/tests/test_blender_e2e.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/tests/test_blender_e2e.py

## File: skills/blender-pipeline/editing/tests/test_contracts.py
size: 3192
sha: 8a97a759b93753552b2fd660f36425ecaae30b7a
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/tests/test_contracts.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/tests/test_contracts.py

## File: skills/blender-pipeline/editing/tests/test_geometry.py
size: 4495
sha: ddfebe77e2a220ea2ec8adbb6f5d7b9715b02169
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/tests/test_geometry.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/tests/test_geometry.py

## File: skills/blender-pipeline/editing/tests/test_qa.py
size: 7497
sha: 0b4cde6aa3f3b5c7dc103b7a771bc168f1902dc0
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/tests/test_qa.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/tests/test_qa.py

## File: skills/blender-pipeline/editing/tests/test_schemas.py
size: 1462
sha: c835d885bbd07c0854ed111656d388d1d19f9bb1
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/tests/test_schemas.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/editing/tests/test_schemas.py

## File: skills/blender-pipeline/generation/requirements-knowledge.txt
size: 128
sha: 868fd1e1a952dbcd21f545cf38c7e27eb18889d0
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/requirements-knowledge.txt

```text
-r requirements.txt

# Optional semantic knowledge indexing and retrieval.
qdrant-client>=1.11,<2
sentence-transformers>=3.0,<6
```

## File: skills/blender-pipeline/generation/requirements.txt
size: 237
sha: 161eec9ad7419347537843693015dd2f47981d5b
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/requirements.txt

```text
# Runtime dependencies outside Blender's bundled Python.
Pillow>=10.4,<13
requests>=2.32,<3
Markdown>=3.6,<4  # Optional HTML view of the visual tutorial.

# Blender provides bpy, bpy_extras, and mathutils. Do not install them with pip.
```

## File: skills/blender-pipeline/generation/scripts/agent_api_trace.py
size: 15899
sha: 3407fdfa74c6999cc36531061b9e67935201ced9
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/agent_api_trace.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/agent_api_trace.py

## File: skills/blender-pipeline/generation/scripts/agent_trajectory.py
size: 62047
sha: 09dad1f05640b3481b0566a4056bbb9a41a56b87
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/agent_trajectory.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/agent_trajectory.py

## File: skills/blender-pipeline/generation/scripts/blender_knowledge_common.py
size: 23288
sha: 351deabc1d7a15ceba8d75d6bef3859060af7597
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/blender_knowledge_common.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/blender_knowledge_common.py

## File: skills/blender-pipeline/generation/scripts/blender_version_registry.py
size: 26111
sha: 3619c43cde0c4a8e38bc428a5f19f77dcc1b6211
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/blender_version_registry.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/blender_version_registry.py

## File: skills/blender-pipeline/generation/scripts/build_blender_knowledge_index.py
size: 19711
sha: 07f59ba8aae4a04ebb688f6948f29475bcc6d602
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/build_blender_knowledge_index.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/build_blender_knowledge_index.py

## File: skills/blender-pipeline/generation/scripts/build_pipeline_specs.py
size: 44474
sha: ed9e8cfc8aeaf03785b0f3703a4afb99c19cd60c
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/build_pipeline_specs.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/build_pipeline_specs.py

## File: skills/blender-pipeline/generation/scripts/camera_framing.py
size: 4047
sha: a0b481aad375164007fe9fa2076e45229e6b61f8
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/camera_framing.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/camera_framing.py

## File: skills/blender-pipeline/generation/scripts/codex_cli_chat_bridge.py
size: 9919
sha: a77a9f25d2de9dadf9256abf283acf851e1004a6
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/codex_cli_chat_bridge.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/codex_cli_chat_bridge.py

## File: skills/blender-pipeline/generation/scripts/embed_markdown_images.py
size: 3435
sha: 1734c64fbeb4b284ae205520dbbacdb3dc1fd551
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/embed_markdown_images.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/embed_markdown_images.py

## File: skills/blender-pipeline/generation/scripts/extract_workflow_evidence.py
size: 17718
sha: 55f2833151743454653f68387939c2953235a431
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/extract_workflow_evidence.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/extract_workflow_evidence.py

## File: skills/blender-pipeline/generation/scripts/generate_code_tutorial.py
size: 9986
sha: e9bd4500794cbaaa6d9b2e3e16bf87e900cbad5b
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/generate_code_tutorial.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/generate_code_tutorial.py

## File: skills/blender-pipeline/generation/scripts/generate_rich_tutorial_chunks.py
size: 23657
sha: 11bb8259876c4d60e9eb51c0d5f515988f761478
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/generate_rich_tutorial_chunks.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/generate_rich_tutorial_chunks.py

## File: skills/blender-pipeline/generation/scripts/merge_rich_tutorial_chunks.py
size: 9175
sha: 88febab672726ff3e7896d8c154b4679954beac7
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/merge_rich_tutorial_chunks.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/merge_rich_tutorial_chunks.py

## File: skills/blender-pipeline/generation/scripts/model_direct_generation_contracts.py
size: 16359
sha: b89ee41d5474032653df670ce4ff3281a546b5b0
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/model_direct_generation_contracts.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/model_direct_generation_contracts.py

## File: skills/blender-pipeline/generation/scripts/model_direct_generation_v3_harness.py
size: 158209
sha: 30f8aeeb465e26d8e30d2c03842d27c08254ed52
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/model_direct_generation_v3_harness.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/model_direct_generation_v3_harness.py

## File: skills/blender-pipeline/generation/scripts/prepare_rich_tutorial_evidence.py
size: 16652
sha: febc255ed8baad959ecd37b41d34d4bbb17edf83
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/prepare_rich_tutorial_evidence.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/prepare_rich_tutorial_evidence.py

## File: skills/blender-pipeline/generation/scripts/project_paths.py
size: 1458
sha: 62e01c5c73bd8becc509d0251e9b31c0a42a78f3
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/project_paths.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/project_paths.py

## File: skills/blender-pipeline/generation/scripts/render_asset_six_views_turntable.py
size: 133240
sha: f8729f64d23eca3a6669d7ee50af482068c326e9
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/render_asset_six_views_turntable.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/render_asset_six_views_turntable.py

## File: skills/blender-pipeline/generation/scripts/render_illustrated_tutorial.py
size: 11489
sha: 3bb759735adfcad9ba395c5adcd55a0463dcc369
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/render_illustrated_tutorial.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/render_illustrated_tutorial.py

## File: skills/blender-pipeline/generation/scripts/render_knowledge.py
size: 61678
sha: e05a3a4ada73fa5a42e78b64b929651ec6325467
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/render_knowledge.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/render_knowledge.py

## File: skills/blender-pipeline/generation/scripts/retrieve_blender_knowledge.py
size: 16789
sha: 5497bf26f91ebab7b32164662b8013a80614b8c1
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/retrieve_blender_knowledge.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/retrieve_blender_knowledge.py

## File: skills/blender-pipeline/generation/scripts/run_video_replay_main.py
size: 53919
sha: 805af6af439442d79afee6d4c8b193e1f84f7a48
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/run_video_replay_main.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/run_video_replay_main.py

## File: skills/blender-pipeline/generation/scripts/run_video_strict_replay.py
size: 166489
sha: 0f0492288f1d439b6547fe1bee5e81e38a74d12f
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/run_video_strict_replay.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/run_video_strict_replay.py

## File: skills/blender-pipeline/generation/scripts/rw1_static_interchange_framing.py
size: 14872
sha: 02ff70b4f466f476eaf8687f129a7e7251db9b7a
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/rw1_static_interchange_framing.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/rw1_static_interchange_framing.py

## File: skills/blender-pipeline/generation/scripts/scan_blender_version_ocr.py
size: 10444
sha: e2274fbeb23c80a34d5eb9cc79c9471ae4277cfb
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/scan_blender_version_ocr.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/scan_blender_version_ocr.py

## File: skills/blender-pipeline/generation/scripts/update_replay_knowledge_base.py
size: 27852
sha: 48ad675f7a564fe8ea558461a32cd6cc8b856aad
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/update_replay_knowledge_base.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/update_replay_knowledge_base.py

## File: skills/blender-pipeline/generation/scripts/video_replay_animation_contract.py
size: 21959
sha: 9ec0d150b35a627e8ad87cb92954f74abb2e0efc
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/video_replay_animation_contract.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/video_replay_animation_contract.py

## File: skills/blender-pipeline/generation/scripts/video_replay_delivery_contract.py
size: 8075
sha: 1a77730d28220b35aeb26bc3aa0dd683a2e371db
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/video_replay_delivery_contract.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/video_replay_delivery_contract.py

## File: skills/blender-pipeline/generation/scripts/video_replay_model_client.py
size: 31746
sha: 2892e503a93311cd6d8dee81ef2ddc2ba8f51b66
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/video_replay_model_client.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/video_replay_model_client.py

## File: skills/blender-pipeline/generation/scripts/video_replay_paid_api.py
size: 80632
sha: fa2c351306520b94c7264d490de8a6ef619ca220
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/video_replay_paid_api.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/video_replay_paid_api.py

## File: skills/blender-pipeline/generation/scripts/video_replay_provider_usage.py
size: 76663
sha: 9437d1b00ebc6b63aeddeb93f1919904eaec82dc
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/video_replay_provider_usage.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/scripts/video_replay_provider_usage.py

## File: skills/blender-pipeline/generation/tests/test_blender_e2e.py
size: 8398
sha: 8231e183d177c921fe8dace6a5190bc545a47b65
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_blender_e2e.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_blender_e2e.py

## File: skills/blender-pipeline/generation/tests/test_camera_framing.py
size: 1295
sha: f2a5a9ac192f1f768acec763adf386c206405ebd
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_camera_framing.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_camera_framing.py

## File: skills/blender-pipeline/generation/tests/test_camera_framing_blender.py
size: 2677
sha: 1905cf38e6e12010514865a160e9ab53b31c6455
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_camera_framing_blender.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_camera_framing_blender.py

## File: skills/blender-pipeline/generation/tests/test_codex_cli_bridge.py
size: 13514
sha: c0f1970ae34c55d9003fc3778992136f37660b6c
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_codex_cli_bridge.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_codex_cli_bridge.py

## File: skills/blender-pipeline/generation/tests/test_generation_contracts.py
size: 6610
sha: 44e02f53b173c1fbcfa407e9e9e1b4ac59398b76
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_generation_contracts.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_generation_contracts.py

## File: skills/blender-pipeline/generation/tests/test_generation_delivery.py
size: 31929
sha: 427e3f63e9ebe75d6acf27fe0782cac4277be80f
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_generation_delivery.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_generation_delivery.py

## File: skills/blender-pipeline/generation/tests/test_generation_portability.py
size: 7607
sha: 8b559a2914469d107f1cd515950e4dc749128111
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_generation_portability.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_generation_portability.py

## File: skills/blender-pipeline/generation/tests/test_pipeline_spec_signals.py
size: 15897
sha: 8ed6237e9ed69291b3b8b4239e335bb1912c5f6b
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_pipeline_spec_signals.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_pipeline_spec_signals.py

## File: skills/blender-pipeline/generation/tests/test_render_device_policy.py
size: 8261
sha: dd0f4da339710f99ae86928426c4593acfbf7ac8
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_render_device_policy.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_render_device_policy.py

## File: skills/blender-pipeline/generation/tests/test_success_knowledge.py
size: 14952
sha: fca3ea2feb89efb2233c8c046090b21ba26ac9e3
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_success_knowledge.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/generation/tests/test_success_knowledge.py

## File: skills/blender-pipeline/knowledge/editing.md
size: 12811
sha: cced01ebdface2df7e8558e378285cd4011916fc
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/editing.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/editing.md

## File: skills/blender-pipeline/knowledge/evidence-and-routing.md
size: 7904
sha: a11b60f73765008f209d1f5f49a8f86a27747842
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/evidence-and-routing.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/evidence-and-routing.md

## File: skills/blender-pipeline/knowledge/generation.md
size: 12245
sha: 861caedc262b1c4cf89ea9d35ae0e22ad1e600e7
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/generation.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/generation.md

## File: skills/blender-pipeline/knowledge/index.md
size: 2402
sha: 23374e1c821aa1ee1ab568cee67a5ff72f7a36eb
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/index.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/index.md

## File: skills/blender-pipeline/knowledge/manifest.json
size: 1423
sha: 6e26219ba592878f0b2bb0cffb4e8f6d01440c6a
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/manifest.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/manifest.json

## File: skills/blender-pipeline/knowledge/manifest.schema.json
size: 1709
sha: 4d4688c5032bec00eaf392dc23c09952414ad71d
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/manifest.schema.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/manifest.schema.json

## File: skills/blender-pipeline/knowledge/operations-and-knowledge.md
size: 17604
sha: dce75c514666c138f2981847d69981f082b51b20
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/operations-and-knowledge.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/operations-and-knowledge.md

## File: skills/blender-pipeline/knowledge/rendering-and-dynamics.md
size: 10828
sha: 29734f83a72540cd98467ae383eabbdca6214a1e
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/rendering-and-dynamics.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/knowledge/rendering-and-dynamics.md

## File: skills/blender-pipeline/reproduction/knowledge/manifest.json
size: 235534
sha: 2a9b5e1af466ed0f1ce16ab55b504bc2915d3e77
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/knowledge/manifest.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/knowledge/manifest.json

## File: skills/blender-pipeline/reproduction/knowledge/public_media_attestations.json
size: 12186
sha: dfbb7d8b4ca5d5f5a4a28f1d21682554cf6f8664
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/knowledge/public_media_attestations.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/knowledge/public_media_attestations.json

## File: skills/blender-pipeline/reproduction/knowledge/public_showcase_inventory.json
size: 39523
sha: 66a79158c20deb3c4df818432e18f270bd4fb9ff
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/knowledge/public_showcase_inventory.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/knowledge/public_showcase_inventory.json

## File: skills/blender-pipeline/reproduction/references/execution-contract.md
size: 3970
sha: 04aa190292dbfcdddb264081beeaba95782e9496
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/references/execution-contract.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/references/execution-contract.md

## File: skills/blender-pipeline/reproduction/scripts/export_public_showcase_knowledge.py
size: 15288
sha: 5ef9a38a95e4cf0830e88fc761b0b93324030000
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/scripts/export_public_showcase_knowledge.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/scripts/export_public_showcase_knowledge.py

## File: skills/blender-pipeline/reproduction/scripts/launch_video2blender_reproduction.py
size: 55743
sha: 3c740e838ca5e081fb0b2c215d8109269c3959d9
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/scripts/launch_video2blender_reproduction.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/scripts/launch_video2blender_reproduction.py

## File: skills/blender-pipeline/reproduction/scripts/reproduce.sh
size: 168
sha: 8309232ab53d73a0e2349de2d9c798ed8434be45
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/scripts/reproduce.sh

```text
#!/usr/bin/env bash
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

exec python3 "$SCRIPT_DIR/launch_video2blender_reproduction.py" "$@"
```

## File: skills/blender-pipeline/reproduction/scripts/validate_public_knowledge.py
size: 9402
sha: 712806cf21c4b19ca1272e6bc79c8307d48ac2e2
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/scripts/validate_public_knowledge.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/scripts/validate_public_knowledge.py

## File: skills/blender-pipeline/reproduction/tests/test_reproduction_contracts.py
size: 11884
sha: 7b8276488064579d2464ec30930edbafb32a95d3
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/tests/test_reproduction_contracts.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/reproduction/tests/test_reproduction_contracts.py

## File: skills/blender-pipeline/tests/test_codex_skill_launcher.py
size: 12341
sha: aaa4a1a8e1fc16dd266cf6f8b2c30f49fe57f9b1
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tests/test_codex_skill_launcher.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tests/test_codex_skill_launcher.py

## File: skills/blender-pipeline/tests/test_input_asset_topology.py
size: 3921
sha: d7ec61812e674d2eef05d2b9fbe4ab901098a8a5
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tests/test_input_asset_topology.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tests/test_input_asset_topology.py

## File: skills/blender-pipeline/tests/test_knowledge_contract.py
size: 4718
sha: 8f601d3a5fc99176fc617d08dca96253ef64bd16
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tests/test_knowledge_contract.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tests/test_knowledge_contract.py

## File: skills/blender-pipeline/tests/test_root_launchers.py
size: 38681
sha: 33f72528ff4ae0b94d55142ad81180d9f6fd0185
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tests/test_root_launchers.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tests/test_root_launchers.py

## File: skills/blender-pipeline/tests/test_router_and_package.py
size: 3338
sha: af83314e64daada6d2f6dd84ac17496c2e5810f7
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tests/test_router_and_package.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tests/test_router_and_package.py

## File: skills/blender-pipeline/tutorial-extraction/agents/openai.yaml
size: 310
sha: af1fac7ecdc5b2456c2207a68fde680dbaae078e
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/agents/openai.yaml

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/agents/openai.yaml

## File: skills/blender-pipeline/tutorial-extraction/references/blender-capability-rubric.md
size: 2118
sha: f2f971e2594a60e5845c022c1fc4c6667c09a992
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/references/blender-capability-rubric.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/references/blender-capability-rubric.md

## File: skills/blender-pipeline/tutorial-extraction/references/evidence-ledger.md
size: 1200
sha: f04f144eae29c9d4d16b1a09ff853ae1ed3620cb
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/references/evidence-ledger.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/references/evidence-ledger.md

## File: skills/blender-pipeline/tutorial-extraction/references/markdown-layout.md
size: 1826
sha: 4935253cf6eceb941676995af8b33f604287675a
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/references/markdown-layout.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/references/markdown-layout.md

## File: skills/blender-pipeline/tutorial-extraction/references/output-contract.md
size: 5700
sha: c16278362a62419cb8cb1fe30e1587b3eb929a3b
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/references/output-contract.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/references/output-contract.md

## File: skills/blender-pipeline/tutorial-extraction/references/profiles-and-evidence.md
size: 3350
sha: ff0a124f58fd2654ed072871fb84232371ebc282
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/references/profiles-and-evidence.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/references/profiles-and-evidence.md

## File: skills/blender-pipeline/tutorial-extraction/requirements.txt
size: 72
sha: de88d4eeccc5a727c637f978e3be7b1722a551ea
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/requirements.txt

```text
Pillow>=10.4,<13
jsonschema>=4.23,<5
requests>=2.32,<3
Markdown>=3.6,<4
```

## File: skills/blender-pipeline/tutorial-extraction/schemas/manifest.schema.json
size: 2743
sha: 928fcf748d313b0509e028d965959d7cb0f2ebf9
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/schemas/manifest.schema.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/schemas/manifest.schema.json

## File: skills/blender-pipeline/tutorial-extraction/schemas/steps.schema.json
size: 2555
sha: 9d44b041c2c4a515ff4c973bf7a6e5e156247e16
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/schemas/steps.schema.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/schemas/steps.schema.json

## File: skills/blender-pipeline/tutorial-extraction/scripts/extract_video_tutorial.py
size: 9305
sha: 6b8aa807a8b4331d579d7fa4001f0b8a7e975733
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/extract_video_tutorial.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/extract_video_tutorial.py

## File: skills/blender-pipeline/tutorial-extraction/scripts/legacy_rich_tutorial_pipeline.py
size: 27433
sha: 46077bee143796a86c46a0fc7ac2740194ab03a3
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/legacy_rich_tutorial_pipeline.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/legacy_rich_tutorial_pipeline.py

## File: skills/blender-pipeline/tutorial-extraction/scripts/prepare_video.py
size: 5673
sha: 7daf379af81f35feb0faf134b45a7abd89e0089a
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/prepare_video.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/prepare_video.py

## File: skills/blender-pipeline/tutorial-extraction/scripts/tutorial_extraction_core.py
size: 176589
sha: a7479e57d8c77a12dce1aaad43eb59ebc18d6b4f
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/tutorial_extraction_core.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/tutorial_extraction_core.py

## File: skills/blender-pipeline/tutorial-extraction/scripts/validate_tutorial_package.py
size: 33715
sha: 85b06b5423a22d4be56f391db9145bff128ed59f
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/validate_tutorial_package.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/validate_tutorial_package.py

## File: skills/blender-pipeline/tutorial-extraction/scripts/validate_visual_package.py
size: 9365
sha: abaddfd1f591b093914884de9a301fd92a1d92bb
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/validate_visual_package.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/validate_visual_package.py

## File: skills/blender-pipeline/tutorial-extraction/scripts/visual_tutorial_pipeline.py
size: 37069
sha: 5f154980bd430e5479e350d67ec2db7dae65f1d4
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/visual_tutorial_pipeline.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/scripts/visual_tutorial_pipeline.py

## File: skills/blender-pipeline/tutorial-extraction/tests/test_audio_stream_preflight.py
size: 3017
sha: 79cbe590332dea95aa078cbd75fc05e3f2e55c90
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/tests/test_audio_stream_preflight.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/tests/test_audio_stream_preflight.py

## File: skills/blender-pipeline/tutorial-extraction/tests/test_legacy_rich_tutorial_pipeline.py
size: 17273
sha: 63a9b60fa5ab47bf01170840f3437006d3361918
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/tests/test_legacy_rich_tutorial_pipeline.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/tests/test_legacy_rich_tutorial_pipeline.py

## File: skills/blender-pipeline/tutorial-extraction/tests/test_visual_tutorial_pipeline.py
size: 23019
sha: 2e545ba1cdb54bbf387c20571423e55486b6eeb5
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/tests/test_visual_tutorial_pipeline.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/freedomintelligence/blenderlore/blob/main/skills/blender-pipeline/tutorial-extraction/tests/test_visual_tutorial_pipeline.py

## File: README.md
upstream: https://github.com/freedomintelligence/blenderlore/blob/main/README.md

````text
English | <a href="README_zh-CN.md">简体中文</a>

<h2 align="center">BlenderLore: Learning 3D Coding from Internet Tutorial Videos</h2>

<p align="center">
  <strong>If you like our project, please give us a star ⭐ on GitHub for the latest update.
</strong>
</p>

<p align="center">
  <a href="https://blenderlore.github.io/"><img src="https://img.shields.io/badge/Project-Website-7b61ff" alt="Project Website"></a>
  <a href="https://github.com/FreedomIntelligence/BlenderLore"><img src="https://img.shields.io/badge/GitHub-Repository-111111.svg?logo=github" alt="GitHub Repository"></a>
  <a href="https://huggingface.co/datasets/FreedomIntelligence/BlenderLore"><img src="https://img.shields.io/badge/HuggingFace-Dataset-f6c344.svg?logo=huggingface" alt="Hugging Face Dataset"></a>
  <img src="https://img.shields.io/badge/Paper-Coming_Soon-8f7ad8" alt="Paper Coming Soon">
</p>

## 🔭 Overview

BlenderLore is a dataset and pipeline for acquiring and reusing procedural knowledge from internet tutorial videos for 3D coding. It converts video evidence into illustrated tutorials, reconstructs editable assets in Blender Python, and extracts reviewed methods for future creation tasks. The collection contains **about 22K project instances associated with over 3K tutorial videos** from YouTube and Bilibili.

**Generalization is central to BlenderLore.** Executing code and inspecting geometry, appearance, and motion ground the inferred methods in concrete implementations. Agents can then retrieve, adapt, and combine methods from different tutorials for new goals. **BlenderLore Skill** packages the reconstruction workflow and procedural knowledge library for existing coding agents; knowledge accumulates externally without updating model parameters.

![A complete BlenderLore example: dynamic fur, from tutorial evidence to illustrated steps, Blender Python, and an animated asset](docs/assets/blenderlore_sample.png)

*A complete example: dynamic fur. Illustrated steps connect the source video to executable reconstruction and reusable procedural knowledge.*

## 🧩 Method

![BlenderLore pipeline: tutorial videos, multimodal evidence, illustrated workflows and knowledge retrieval, a coding agent loop, and verified deliverables](docs/assets/blenderlore_method.png)

1. **Recover illustrated workflows.** Align video frames, narration, on-screen text, and interface changes into ordered steps, recording inputs, operations, parameters, and intermediate results.
2. **Ground methods in source assets.** Use creator-provided projects when available, repair missing components, and connect tutorial steps to concrete implementations.
3. **Reconstruct and inspect.** Retrieve relevant knowledge, generate Blender Python, execute and render the scene, and repair discrepancies in geometry, appearance, or motion.
4. **Review and retain knowledge.** Record each method's source, retrieval keywords, applicability, implementation excerpt, and checks for the intended result. Human experts review the resulting assets.
5. **Adapt and combine.** Reuse methods across tutorials to create new assets and expand the procedural knowledge library.

## Generalizing Beyond Tutorials

![Cross-tutorial composition: Duck GiGi modeling, transferred rigging and walking, and an iridescent material](docs/assets/blenderlore_composition.png)

BlenderLore creates a walking iridescent Duck GiGi by combining three tutorials: a static character modeling workflow, a rigging and walking method transferred from a baby crocodile, and an iridescent material. The reusable unit is a construction method, allowing agents to adapt and combine knowledge beyond the demonstrated assets.

## 🎁 What You Get

<table>
<tr>
<td width="33%" valign="top">

### 01 · An End-to-End Agent Pipeline

Each run recreates a tutorial workflow and delivers an editable Blender project, a reproduction script, renders, and validation results.

- Editable Asset — `asset.blend`
- Reproduction Script — `reproduce.py`
- Materials & Node Graphs
- Final Render
- Multi-View Renders
- Animation
- Agent Log

</td>
<td width="33%" valign="top">

### 02 · A High-Quality 3D Dataset

About 22K project instances associated with over 3K tutorial videos, built through collection, repair, reconstruction, and cross-tutorial adaptation and composition. Human experts manually check every final asset file.

</td>
<td width="33%" valign="top">

### 03 · A Reusable Procedural Knowledge Library

Reviewed entries record their source, applicability, implementation, and checks. BlenderLore Skill supplies this library and workflow guidance so coding agents can retrieve, adapt, and combine methods for new 3D tasks.

</td>
</tr>
</table>

## 🚀 Quick Start

### 1. Install prerequisites

Install Python 3.10+, Blender, and FFmpeg (including `ffprobe`), with Blender and FFmpeg on `PATH`. Commands below target macOS/Linux; on Windows, use Linux Python and Blender in WSL. Replace example paths with your own.

```bash
git clone https://github.com/FreedomIntelligence/BlenderLore.git
cd BlenderLore
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt
```

For Codex, install and sign in to Codex CLI using the [official documentation](https://developers.openai.com/codex/cli/), and ensure the client can run `codex`.

### 2. Install Skills

Run from the repository root to install the Skill into the current user's Codex environment:

```bash
mkdir -p "$HOME/.agents/skills"
ln -s "$PWD/skills/blender-pipeline" "$HOME/.agents/skills/blender-pipeline"
```

### 3. Configure rendering

Cycles uses the CPU by default. Omit the Blender path setting if Blender is already on `PATH`.

```bash
export BLENDER_PIPELINE_BLENDER=/path/to/blender
export VIDEO2BLENDER_CYCLES_BACKEND=CPU
```

For GPU rendering, replace `CPU` with the appropriate backend: `OPTIX` or `CUDA` for NVIDIA, `METAL` for Apple Silicon, `HIP` for AMD, or `ONEAPI` for Intel.

### 4. Configure inputs and outputs

Keep input files on your computer. For API mode, enter their paths in the terminal launch command in step 5; for Codex, provide paths or links directly in the client's chat composer.

| Input | API argument | Provide in Codex |
| --- | --- | --- |
| Local video | `--video-file` | Absolute path to the video |
| Video URL | `--video-url` | Full HTTPS video URL |
| Markdown tutorial | `--tutorial` | Absolute path to the `.md` file |

Markdown tutorials need numbered operations and their referenced images. Text-only tutorials also require a final reference image.

Choose a new or empty output directory outside the repository: use `--output-dir` in API mode, or specify it in the Codex conversation. Output formats are fixed; main files appear as their corresponding stages complete:

```text
run_001/
  tutorial.md             # Illustrated tutorial
  reproduce.py            # Blender Python code
  asset.blend             # Editable project
  render.png              # Rendered image
  six_views/              # Static multi-view renders, when applicable
  final_effect.mp4        # Animation or turntable video, when applicable
  pipeline_review.json    # Review results
```

### 5. Start with API / Codex

#### API

Open a terminal at the repository root and run this command for first-time setup:

```bash
python run_api.py --configure --config "$HOME/.config/blender-pipeline/pipeline.json"
```

At the terminal prompts, enter an HTTPS API endpoint ending in `/chat/completions` and your API key. The endpoint is saved in the `endpoint` field of `~/.config/blender-pipeline/pipeline.json`; the key is saved in `model_api_key` in the same directory. Edit these files to change the configuration later.

Launch from the same terminal, replacing the input path and output directory with your own. Use the corresponding argument from step 4 for other input types:

```bash
python run_api.py --config "$HOME/.config/blender-pipeline/pipeline.json" \
  --video-file /path/to/input/tutorial.mp4 --output-dir /path/to/data/run_api
```

F
````
