Upload scripts/run_primitive_collision_proxy.py with huggingface_hub

scripts/run_primitive_collision_proxy.py

@@ -0,0 +1,777 @@
+#!/usr/bin/env python3
+"""
+Generate primitive collision proxies from visual OBJ meshes.
+
+This tool complements CoACD convex decomposition for thin rod / rack / grid
+assets. It keeps raw assets untouched and writes derived outputs under:
+
+  assets/<source>/derived/primitive_collision_proxies/<category>/<asset_id>_<variant>/
+
+The generated JSON is the source of truth. MuJoCo and cuRobo fragments are both
+exported from that same JSON so downstream planning and simulation can share the
+same collision approximation.
+"""
+
+import argparse
+import csv
+import hashlib
+import json
+import math
+import re
+from collections import defaultdict
+from dataclasses import asdict, dataclass
+from datetime import date
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+MANIFEST = ROOT / "manifest" / "assets.jsonl"
+Vec3 = tuple[float, float, float]
+
+
+@dataclass(frozen=True)
+class CuboidProxy:
+    name: str
+    source_mesh: str
+    pos: Vec3
+    size: Vec3
+    component: int
+    segment: int
+    category: str
+
+    @property
+    def dims(self):
+        return tuple(2.0 * v for v in self.size)
+
+
+class DisjointSet:
+    def __init__(self, n):
+        self.parent = list(range(n))
+        self.rank = [0] * n
+
+    def find(self, x):
+        while self.parent[x] != x:
+            self.parent[x] = self.parent[self.parent[x]]
+            x = self.parent[x]
+        return x
+
+    def union(self, a, b):
+        ra = self.find(a)
+        rb = self.find(b)
+        if ra == rb:
+            return
+        if self.rank[ra] < self.rank[rb]:
+            ra, rb = rb, ra
+        self.parent[rb] = ra
+        if self.rank[ra] == self.rank[rb]:
+            self.rank[ra] += 1
+
+
+def parse_simple_yaml(path):
+    data = {}
+    current_key = None
+    for raw in path.read_text().splitlines():
+        if not raw.strip() or raw.lstrip().startswith("#"):
+            continue
+        if raw.startswith("  - ") and current_key:
+            data.setdefault(current_key, []).append(raw.strip()[2:].strip())
+            continue
+        if ":" in raw and not raw.startswith(" "):
+            key, value = raw.split(":", 1)
+            key = key.strip()
+            value = value.strip()
+            current_key = key
+            if value == "":
+                data[key] = []
+            elif value in {"[]", "{}"}:
+                data[key] = [] if value == "[]" else {}
+            else:
+                data[key] = value.strip('"').strip("'")
+    return data
+
+
+def yaml_scalar(value):
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if value is None:
+        return "null"
+    if isinstance(value, (int, float)):
+        return str(value)
+    text = str(value)
+    if text == "":
+        return '""'
+    if any(ch in text for ch in [":", "#", "{", "}", "[", "]", ",", '"', "'", "\n"]) or text.startswith(" ") or text.endswith(" "):
+        return json.dumps(text, ensure_ascii=False)
+    return text
+
+
+def dump_yaml(mapping, indent=0):
+    lines = []
+    pad = " " * indent
+    for key, value in mapping.items():
+        if isinstance(value, dict):
+            lines.append(f"{pad}{key}:")
+            lines.extend(dump_yaml(value, indent + 2))
+        elif isinstance(value, list):
+            if not value:
+                lines.append(f"{pad}{key}: []")
+            else:
+                lines.append(f"{pad}{key}:")
+                for item in value:
+                    if isinstance(item, dict):
+                        lines.append(f"{pad}  -")
+                        lines.extend(dump_yaml(item, indent + 4))
+                    else:
+                        lines.append(f"{pad}  - {yaml_scalar(item)}")
+        else:
+            lines.append(f"{pad}{key}: {yaml_scalar(value)}")
+    return lines
+
+
+def xml_escape(value):
+    return (
+        str(value)
+        .replace("&", "&amp;")
+        .replace('"', "&quot;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+    )
+
+
+def safe_name(text):
+    text = Path(text).stem if "/" in text else text
+    text = re.sub(r"[^0-9A-Za-z_]+", "_", text)
+    text = re.sub(r"_+", "_", text).strip("_")
+    if not text:
+        text = "mesh"
+    if text[0].isdigit():
+        text = f"m_{text}"
+    return text
+
+
+def rel_to_root(path):
+    resolved = path.resolve()
+    try:
+        return resolved.relative_to(ROOT).as_posix()
+    except ValueError:
+        return resolved.as_posix()
+
+
+def sha256_file(path):
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def require_raw_asset(raw_asset_dir):
+    raw_asset_dir = raw_asset_dir.resolve()
+    try:
+        raw_rel = raw_asset_dir.relative_to(ROOT / "assets")
+    except ValueError as exc:
+        raise SystemExit("raw_asset_dir must be under this repository's assets/ directory") from exc
+
+    parts = raw_rel.parts
+    if len(parts) < 5 or parts[1] != "raw":
+        raise SystemExit("raw_asset_dir must be under assets/<source>/raw/<asset_type>/<category>/<asset_id>")
+    return raw_asset_dir, parts[0], parts[2], parts[3], parts[4]
+
+
+def discover_meshes(raw_asset_dir, patterns):
+    meshes = []
+    for pattern in patterns:
+        meshes.extend(raw_asset_dir.glob(pattern))
+    return sorted({p.resolve() for p in meshes if p.is_file()})
+
+
+def resolve_mesh_args(raw_asset_dir, mesh_args, patterns):
+    if mesh_args:
+        meshes = []
+        for item in mesh_args:
+            path = Path(item).expanduser()
+            if not path.is_absolute():
+                path = raw_asset_dir / path
+            if not path.exists():
+                raise SystemExit(f"mesh does not exist: {path}")
+            meshes.append(path.resolve())
+        return meshes
+    meshes = discover_meshes(raw_asset_dir, patterns)
+    if not meshes:
+        raise SystemExit("no mesh found. Pass --mesh or adjust --mesh-glob.")
+    return meshes
+
+
+def parse_obj(path):
+    vertices = []
+    faces = []
+    for line in path.read_text(errors="ignore").splitlines():
+        if line.startswith("v "):
+            parts = line.split()
+            vertices.append((float(parts[1]), float(parts[2]), float(parts[3])))
+        elif line.startswith("f "):
+            indices = []
+            for token in line.split()[1:]:
+                raw = token.split("/")[0]
+                if not raw:
+                    continue
+                idx = int(raw)
+                if idx < 0:
+                    idx = len(vertices) + idx + 1
+                indices.append(idx - 1)
+            if len(indices) >= 2:
+                faces.append(indices)
+    if not vertices:
+        raise RuntimeError(f"no OBJ vertices found: {path}")
+    return vertices, faces
+
+
+def connected_vertex_components(vertices, faces):
+    dsu = DisjointSet(len(vertices))
+    for face in faces:
+        first = face[0]
+        for idx in face[1:]:
+            dsu.union(first, idx)
+    groups = defaultdict(list)
+    for idx in range(len(vertices)):
+        groups[dsu.find(idx)].append(idx)
+    return sorted(groups.values(), key=lambda group: (-len(group), min(group)))
+
+
+def bbox(points):
+    mins = [min(p[i] for p in points) for i in range(3)]
+    maxs = [max(p[i] for p in points) for i in range(3)]
+    return (mins[0], mins[1], mins[2]), (maxs[0], maxs[1], maxs[2])
+
+
+def padded_cuboid(name, source_mesh, points, component, segment, padding, min_half_extent, category):
+    mins, maxs = bbox(points)
+    pos = tuple((mins[i] + maxs[i]) * 0.5 for i in range(3))
+    size = tuple(max((maxs[i] - mins[i]) * 0.5 + padding, min_half_extent) for i in range(3))
+    return CuboidProxy(
+        name=name,
+        source_mesh=source_mesh,
+        pos=pos,
+        size=size,
+        component=component,
+        segment=segment,
+        category=category,
+    )
+
+
+def split_component_to_cuboids(
+    component_id,
+    vertex_ids,
+    vertices,
+    source_mesh,
+    name_prefix,
+    segment_length,
+    padding,
+    min_half_extent,
+    min_segment_vertices,
+):
+    points = [vertices[i] for i in vertex_ids]
+    mins, maxs = bbox(points)
+    lengths = [maxs[i] - mins[i] for i in range(3)]
+    axis = max(range(3), key=lambda i: lengths[i])
+    if lengths[axis] <= segment_length:
+        return [
+            padded_cuboid(
+                f"{name_prefix}_c{component_id:03d}_s000",
+                source_mesh,
+                points,
+                component_id,
+                0,
+                padding,
+                min_half_extent,
+                "forbidden",
+            )
+        ]
+
+    segment_count = max(1, math.ceil(lengths[axis] / segment_length))
+    cuboids = []
+    for segment_id in range(segment_count):
+        lo = mins[axis] + lengths[axis] * segment_id / segment_count
+        hi = mins[axis] + lengths[axis] * (segment_id + 1) / segment_count
+        if segment_id == segment_count - 1:
+            hi += 1e-12
+        segment_points = [p for p in points if lo <= p[axis] < hi]
+        if len(segment_points) < min_segment_vertices:
+            continue
+        cuboids.append(
+            padded_cuboid(
+                f"{name_prefix}_c{component_id:03d}_s{segment_id:03d}",
+                source_mesh,
+                segment_points,
+                component_id,
+                segment_id,
+                padding,
+                min_half_extent,
+                "forbidden",
+            )
+        )
+    return cuboids
+
+
+def distance(a, b):
+    return math.sqrt(sum((a[i] - b[i]) ** 2 for i in range(3)))
+
+
+def mark_allowed_contact(cuboids, target, radius):
+    if target is None:
+        return cuboids
+    marked = []
+    for cuboid in cuboids:
+        category = "allowed_contact" if distance(cuboid.pos, target) <= radius else cuboid.category
+        marked.append(
+            CuboidProxy(
+                name=cuboid.name,
+                source_mesh=cuboid.source_mesh,
+                pos=cuboid.pos,
+                size=cuboid.size,
+                component=cuboid.component,
+                segment=cuboid.segment,
+                category=category,
+            )
+        )
+    return marked
+
+
+def build_for_mesh(mesh_path, raw_asset_dir, args):
+    vertices, faces = parse_obj(mesh_path)
+    components = connected_vertex_components(vertices, faces)
+    kept_components = [c for c in components if len(c) >= args.min_component_vertices]
+    mesh_stem = safe_name(mesh_path.stem)
+    rel_mesh = mesh_path.relative_to(raw_asset_dir).as_posix()
+    name_prefix = safe_name(f"{args.name_prefix}_{mesh_stem}") if args.name_prefix else mesh_stem
+
+    cuboids = []
+    for component_id, vertex_ids in enumerate(kept_components):
+        cuboids.extend(
+            split_component_to_cuboids(
+                component_id,
+                vertex_ids,
+                vertices,
+                rel_mesh,
+                name_prefix,
+                args.segment_length,
+                args.padding,
+                args.min_half_extent,
+                args.min_segment_vertices,
+            )
+        )
+    cuboids = mark_allowed_contact(cuboids, args.allowed_contact_target, args.allowed_contact_radius)
+    mins, maxs = bbox(vertices)
+    stats = {
+        "mesh": rel_mesh,
+        "sha256": sha256_file(mesh_path),
+        "vertices": len(vertices),
+        "faces": len(faces),
+        "components_total": len(components),
+        "components_kept": len(kept_components),
+        "cuboids_total": len(cuboids),
+        "forbidden_cuboids": sum(c.category == "forbidden" for c in cuboids),
+        "allowed_contact_cuboids": sum(c.category == "allowed_contact" for c in cuboids),
+        "bbox_min": mins,
+        "bbox_max": maxs,
+        "bbox_size": tuple(maxs[i] - mins[i] for i in range(3)),
+    }
+    return cuboids, stats
+
+
+def write_proxy_json(path, cuboids, stats, params):
+    payload = {
+        "format": "placement_assets.primitive_collision_proxy.v1",
+        "created_at": str(date.today()),
+        "params": params,
+        "stats": stats,
+        "cuboids": [{**asdict(c), "dims": c.dims} for c in cuboids],
+    }
+    path.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+
+
+def write_mjcf_files(mjcf_dir, asset_id, cuboids, class_name, rgba_forbidden, rgba_allowed, group, contype, conaffinity):
+    mjcf_dir.mkdir(parents=True, exist_ok=True)
+    attrs = []
+    if class_name:
+        attrs.append(f'class="{xml_escape(class_name)}"')
+    if group:
+        attrs.append(f'group="{xml_escape(group)}"')
+    if contype:
+        attrs.append(f'contype="{xml_escape(contype)}"')
+    if conaffinity:
+        attrs.append(f'conaffinity="{xml_escape(conaffinity)}"')
+    common = " ".join(attrs)
+    common = f" {common}" if common else ""
+
+    lines = [
+        "<!-- Include this file inside the target body to add primitive collision geoms. -->",
+        "<mujocoinclude>",
+    ]
+    for c in cuboids:
+        pos = " ".join(f"{v:.8f}" for v in c.pos)
+        size = " ".join(f"{v:.8f}" for v in c.size)
+        rgba = rgba_allowed if c.category == "allowed_contact" else rgba_forbidden
+        lines.append(
+            f'  <geom type="box" name="{xml_escape(c.name)}" pos="{pos}" size="{size}" '
+            f'quat="1 0 0 0" rgba="{xml_escape(rgba)}"{common}/>'
+        )
+    lines.extend(["</mujocoinclude>", ""])
+    (mjcf_dir / "primitive_geoms_include.xml").write_text("\n".join(lines))
+
+    body_name = safe_name(f"{asset_id}_primitive_collision")
+    combo = [
+        "<!-- Convenience include for preview or standalone loading.",
+        "     For integration into an existing object, include primitive_geoms_include.xml",
+        "     inside the target body instead. -->",
+        "<mujocoinclude>",
+        "  <worldbody>",
+        f'    <body name="{xml_escape(body_name)}">',
+        '      <include file="primitive_geoms_include.xml"/>',
+        "    </body>",
+        "  </worldbody>",
+        "</mujocoinclude>",
+        "",
+    ]
+    (mjcf_dir / "primitive_collision_include.xml").write_text("\n".join(combo))
+
+
+def write_curobo_world(path, cuboids):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = ["# Generated cuRobo cuboid fragment. Allowed-contact cuboids are omitted."]
+    lines.append("cuboid:")
+    for c in cuboids:
+        if c.category != "forbidden":
+            continue
+        pose = [*c.pos, 1.0, 0.0, 0.0, 0.0]
+        lines.append(f"  {c.name}:")
+        lines.append("    pose: [" + ", ".join(f"{v:.8f}" for v in pose) + "]")
+        lines.append("    dims: [" + ", ".join(f"{v:.8f}" for v in c.dims) + "]")
+    path.write_text("\n".join(lines) + "\n")
+
+
+def write_summary_csv(path, cuboids):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", newline="") as f:
+        writer = csv.DictWriter(
+            f,
+            fieldnames=[
+                "name",
+                "source_mesh",
+                "category",
+                "component",
+                "segment",
+                "pos_x",
+                "pos_y",
+                "pos_z",
+                "size_x",
+                "size_y",
+                "size_z",
+                "dim_x",
+                "dim_y",
+                "dim_z",
+            ],
+        )
+        writer.writeheader()
+        for c in cuboids:
+            writer.writerow(
+                {
+                    "name": c.name,
+                    "source_mesh": c.source_mesh,
+                    "category": c.category,
+                    "component": c.component,
+                    "segment": c.segment,
+                    "pos_x": c.pos[0],
+                    "pos_y": c.pos[1],
+                    "pos_z": c.pos[2],
+                    "size_x": c.size[0],
+                    "size_y": c.size[1],
+                    "size_z": c.size[2],
+                    "dim_x": c.dims[0],
+                    "dim_y": c.dims[1],
+                    "dim_z": c.dims[2],
+                }
+            )
+
+
+def write_report(path, raw_asset_dir, derived_dir, mesh_stats, cuboids):
+    largest = sorted(cuboids, key=lambda c: max(c.size), reverse=True)[:12]
+    lines = [
+        "# Primitive Collision Proxy Report",
+        "",
+        "## Summary",
+        "",
+        f"- Raw asset: `{rel_to_root(raw_asset_dir)}`",
+        f"- Derived asset: `{rel_to_root(derived_dir)}`",
+        f"- Meshes: `{len(mesh_stats)}`",
+        f"- Cuboids: `{len(cuboids)}` total, `{sum(c.category == 'forbidden' for c in cuboids)}` forbidden, `{sum(c.category == 'allowed_contact' for c in cuboids)}` allowed-contact",
+        "",
+        "## Mesh Stats",
+        "",
+        "| mesh | vertices | faces | components kept / total | cuboids | bbox size |",
+        "|---|---:|---:|---:|---:|---:|",
+    ]
+    for stat in mesh_stats:
+        lines.append(
+            f"| `{stat['mesh']}` | `{stat['vertices']}` | `{stat['faces']}` | "
+            f"`{stat['components_kept']} / {stat['components_total']}` | "
+            f"`{stat['cuboids_total']}` | "
+            f"`{tuple(round(v, 6) for v in stat['bbox_size'])}` |"
+        )
+    lines.extend(
+        [
+            "",
+            "## Largest Cuboids",
+            "",
+            "| name | category | pos | half-size |",
+            "|---|---|---:|---:|",
+        ]
+    )
+    for c in largest:
+        lines.append(
+            f"| `{c.name}` | `{c.category}` | "
+            f"`{tuple(round(v, 6) for v in c.pos)}` | "
+            f"`{tuple(round(v, 6) for v in c.size)}` |"
+        )
+    lines.extend(
+        [
+            "",
+            "## Review Checklist",
+            "",
+            "- Inspect `mjcf/primitive_geoms_include.xml` visually before downstream use.",
+            "- Use `proxy/primitive_collision_proxy.json` as the source of truth.",
+            "- Keep allowed-contact cuboids out of cuRobo forbidden worlds.",
+            "- Verify task-specific start, goal, swept path, and allowed-contact penetration separately.",
+        ]
+    )
+    path.write_text("\n".join(lines) + "\n")
+
+
+def append_manifest(row):
+    MANIFEST.parent.mkdir(parents=True, exist_ok=True)
+    existing = []
+    if MANIFEST.exists():
+        existing = [line for line in MANIFEST.read_text().splitlines() if line.strip()]
+    path = row["path"]
+    for line in existing:
+        try:
+            old = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if old.get("path") == path:
+            raise SystemExit(f"manifest already contains path: {path}")
+    with MANIFEST.open("a") as f:
+        f.write(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n")
+
+
+def parse_allowed_contact_target(values):
+    if values is None:
+        return None
+    if len(values) != 3:
+        raise SystemExit("--allowed-contact-target requires exactly 3 numbers")
+    return tuple(float(v) for v in values)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Generate primitive box collision proxies from visual OBJ meshes.")
+    parser.add_argument("raw_asset_dir", help="Raw asset directory under assets/<source>/raw/...")
+    parser.add_argument("--mesh", action="append", default=[], help="Mesh path relative to raw_asset_dir or absolute. Repeatable.")
+    parser.add_argument(
+        "--mesh-glob",
+        action="append",
+        default=["visuals/rack1.obj"],
+        help="Glob relative to raw_asset_dir used when --mesh is omitted. Repeatable.",
+    )
+    parser.add_argument("--variant", default="primitive_boxes_v1", help="Derived asset suffix.")
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=None,
+        help="Optional explicit output directory for inspection. Defaults to the canonical derived asset path.",
+    )
+    parser.add_argument("--overwrite", action="store_true", help="Allow writing into an existing derived directory.")
+    parser.add_argument("--register-manifest", action="store_true", help="Append the derived asset to manifest/assets.jsonl.")
+    parser.add_argument("--name-prefix", default="proxy", help="Prefix for generated geom/cuboid names.")
+    parser.add_argument("--segment-length", type=float, default=0.03, help="Max component segment length before splitting AABBs.")
+    parser.add_argument("--padding", type=float, default=0.001, help="Extra half-extent added to each generated cuboid.")
+    parser.add_argument("--min-half-extent", type=float, default=0.0015, help="Minimum half-extent per cuboid axis.")
+    parser.add_argument("--min-component-vertices", type=int, default=4, help="Discard smaller connected components.")
+    parser.add_argument("--min-segment-vertices", type=int, default=2, help="Discard split segments with fewer vertices.")
+    parser.add_argument("--allowed-contact-target", nargs=3, metavar=("X", "Y", "Z"), help="OBJ-local point used to mark nearby cuboids as allowed contact.")
+    parser.add_argument("--allowed-contact-radius", type=float, default=0.03, help="Radius around allowed-contact target.")
+    parser.add_argument("--class-name", default="primitive_collision", help="MJCF geom class name. Empty string disables class attr.")
+    parser.add_argument("--rgba-forbidden", default="0.8 0.1 0.1 0.45", help="MJCF rgba for forbidden cuboids.")
+    parser.add_argument("--rgba-allowed", default="0.1 0.6 1 0.45", help="MJCF rgba for allowed-contact cuboids.")
+    parser.add_argument("--group", default="0", help="MJCF geom group. Empty string disables group attr.")
+    parser.add_argument("--contype", default="", help="MJCF geom contype. Empty string uses MuJoCo default.")
+    parser.add_argument("--conaffinity", default="", help="MJCF geom conaffinity. Empty string uses MuJoCo default.")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    args.allowed_contact_target = parse_allowed_contact_target(args.allowed_contact_target)
+
+    raw_asset_dir, source, _raw_asset_type, category, source_asset_id = require_raw_asset(Path(args.raw_asset_dir))
+    raw_meta_path = raw_asset_dir / "metadata.yaml"
+    raw_meta = parse_simple_yaml(raw_meta_path) if raw_meta_path.exists() else {}
+    meshes = resolve_mesh_args(raw_asset_dir, args.mesh, args.mesh_glob)
+
+    derived_asset_id = f"{source_asset_id}_{args.variant}"
+    explicit_output_dir = args.output_dir is not None
+    derived_dir = args.output_dir.resolve() if explicit_output_dir else (
+        ROOT / "assets" / source / "derived" / "primitive_collision_proxies" / category / derived_asset_id
+    )
+    if derived_dir.exists() and not args.overwrite:
+        raise SystemExit(f"destination already exists: {derived_dir}. Use --overwrite only if you intend to replace files inside it.")
+    work_dir = derived_dir
+    if not args.overwrite:
+        work_dir = derived_dir.parent / f".{derived_dir.name}.tmp"
+        if work_dir.exists():
+            raise SystemExit(f"temporary output already exists from a previous failed run: {work_dir}")
+
+    (work_dir / "proxy").mkdir(parents=True, exist_ok=True)
+    (work_dir / "mjcf").mkdir(parents=True, exist_ok=True)
+    (work_dir / "curobo").mkdir(parents=True, exist_ok=True)
+    (work_dir / "logs").mkdir(parents=True, exist_ok=True)
+
+    all_cuboids = []
+    mesh_stats = []
+    for mesh_path in meshes:
+        cuboids, stats = build_for_mesh(mesh_path, raw_asset_dir, args)
+        all_cuboids.extend(cuboids)
+        mesh_stats.append(stats)
+
+    params = {
+        "mesh_glob": args.mesh_glob,
+        "variant": args.variant,
+        "segment_length": args.segment_length,
+        "padding": args.padding,
+        "min_half_extent": args.min_half_extent,
+        "min_component_vertices": args.min_component_vertices,
+        "min_segment_vertices": args.min_segment_vertices,
+        "allowed_contact_target": args.allowed_contact_target,
+        "allowed_contact_radius": args.allowed_contact_radius,
+    }
+    write_proxy_json(work_dir / "proxy" / "primitive_collision_proxy.json", all_cuboids, mesh_stats, params)
+    write_mjcf_files(
+        work_dir / "mjcf",
+        source_asset_id,
+        all_cuboids,
+        args.class_name,
+        args.rgba_forbidden,
+        args.rgba_allowed,
+        args.group,
+        args.contype,
+        args.conaffinity,
+    )
+    write_curobo_world(work_dir / "curobo" / "primitive_world.yml", all_cuboids)
+    write_summary_csv(work_dir / "logs" / "cuboids_summary.csv", all_cuboids)
+    write_report(work_dir / "REPORT.md", raw_asset_dir, derived_dir, mesh_stats, all_cuboids)
+
+    license_name = raw_meta.get("license", "unknown")
+    origin_url = raw_meta.get("origin_url", "")
+    global_asset_id = f"{source}.primitive_collision_proxies.{category}.{derived_asset_id}"
+    metadata = {
+        "asset_id": global_asset_id,
+        "source": source,
+        "source_asset_id": source_asset_id,
+        "asset_type": "primitive_collision_proxies",
+        "category": category,
+        "format": "json_mjcf_curobo_collision_proxy",
+        "entry_file": "proxy/primitive_collision_proxy.json",
+        "license": license_name,
+        "origin_url": origin_url,
+        "path": rel_to_root(derived_dir),
+        "storage_mode": "derived",
+        "derived_from": [rel_to_root(raw_asset_dir)],
+        "derivation_method": "primitive_collision_proxy",
+        "proxy_tool": "run_primitive_collision_proxy.py",
+        "proxy_params_file": "logs/proxy_generation.json",
+        "validation_status": "generated",
+        "tags": [source, "primitive_collision_proxy", "collision", "mujoco", "curobo"],
+    }
+    if "readiness_level" in raw_meta:
+        metadata["readiness_level"] = raw_meta["readiness_level"]
+    if "source_commit" in raw_meta:
+        metadata["source_commit"] = raw_meta["source_commit"]
+    (work_dir / "metadata.yaml").write_text("\n".join(dump_yaml(metadata)) + "\n")
+
+    source_refs = {
+        "raw_asset": rel_to_root(raw_asset_dir),
+        "raw_entry_file": rel_to_root(raw_asset_dir / raw_meta.get("entry_file", "model.xml"))
+        if (raw_asset_dir / raw_meta.get("entry_file", "model.xml")).exists()
+        else "",
+        "raw_meshes": [rel_to_root(p) for p in meshes],
+    }
+    (work_dir / "source_refs.yaml").write_text("\n".join(dump_yaml(source_refs)) + "\n")
+    log = {
+        "tool": "run_primitive_collision_proxy.py",
+        "created_at": str(date.today()),
+        "raw_asset": rel_to_root(raw_asset_dir),
+        "derived_asset": rel_to_root(derived_dir),
+        "params": params,
+        "inputs": mesh_stats,
+        "outputs": {
+            "proxy_json": "proxy/primitive_collision_proxy.json",
+            "mjcf_geoms_include": "mjcf/primitive_geoms_include.xml",
+            "mjcf_standalone_include": "mjcf/primitive_collision_include.xml",
+            "curobo_world": "curobo/primitive_world.yml",
+            "cuboids_summary": "logs/cuboids_summary.csv",
+            "report": "REPORT.md",
+        },
+        "cuboids_total": len(all_cuboids),
+        "forbidden_cuboids": sum(c.category == "forbidden" for c in all_cuboids),
+        "allowed_contact_cuboids": sum(c.category == "allowed_contact" for c in all_cuboids),
+    }
+    (work_dir / "logs" / "proxy_generation.json").write_text(json.dumps(log, indent=2, ensure_ascii=False) + "\n")
+
+    readme = f"""# Primitive collision proxy: {source_asset_id}
+
+Source asset:
+
+```text
+{rel_to_root(raw_asset_dir)}
+```
+
+This derived asset stores box primitive collision proxies generated from visual OBJ meshes.
+It is intended for thin rod, rack, shelf, and grid-like structures where convex decomposition
+or coarse hand-authored collision blocks can close physically real gaps.
+
+Use `proxy/primitive_collision_proxy.json` as the source of truth. The MuJoCo and cuRobo
+fragments are generated from the same proxy data.
+"""
+    (work_dir / "README.md").write_text(readme)
+
+    if work_dir != derived_dir:
+        work_dir.rename(derived_dir)
+
+    if args.register_manifest:
+        row = {
+            "asset_id": global_asset_id,
+            "asset_type": "primitive_collision_proxies",
+            "category": category,
+            "entry_file": "proxy/primitive_collision_proxy.json",
+            "format": "json_mjcf_curobo_collision_proxy",
+            "license": license_name,
+            "origin_url": origin_url,
+            "path": rel_to_root(derived_dir),
+            "source": source,
+            "source_asset_id": source_asset_id,
+            "tags": [source, "primitive_collision_proxy", "collision", "mujoco", "curobo"],
+        }
+        append_manifest(row)
+
+    print(rel_to_root(derived_dir))
+    print(
+        f"meshes={len(meshes)} cuboids={len(all_cuboids)} "
+        f"forbidden={sum(c.category == 'forbidden' for c in all_cuboids)} "
+        f"allowed_contact={sum(c.category == 'allowed_contact' for c in all_cuboids)}"
+    )
+    if not args.register_manifest:
+        print("manifest_status=not_registered; rerun with --register-manifest when this derived asset should be indexed")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())