Remove provenance directory

Remove provenance files and stale README references. Videos, task indexes, annotations, and frozen data splits are unchanged.

README.md

@@ -44,5 +44,4 @@ The test-tube task combines three valid batches (11 + 3 + 35 trajectories).
 
 All 558 videos are frame-exact H.264 stream-copy cuts. Full decoding confirmed frame counts,
 timestamps and equality of decoded YUV pixels to the original source cuts. Eight conversion
-tests passed. Source selection, mappings and validation records are under
-[`provenance/evomind-state-20261102/`](provenance/evomind-state-20261102/).
+tests passed.

provenance/evomind-state-20261102/export_order.py

@@ -1,346 +0,0 @@
-#!/usr/bin/env python3
-"""Export explicitly selected LeRobot v3 recordings to ProPriMem, offline."""
-
-import argparse
-from fractions import Fraction
-import hashlib
-import json
-import math
-from pathlib import Path
-import re
-import statistics
-import subprocess
-
-
-CAMERAS = {
-    "main_view": "observation.images.right_environment_1",
-    "left_view": "observation.images.left_wrist",
-    "right_view": "observation.images.right_wrist",
-}
-
-
-def sha256(path):
-    h = hashlib.sha256()
-    with Path(path).open("rb") as f:
-        for block in iter(lambda: f.read(8 * 1024**2), b""):
-            h.update(block)
-    return h.hexdigest()
-
-
-def write_json(path, value):
-    path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-
-
-def child(root, relative):
-    path = (root / relative).resolve()
-    if not path.is_relative_to(root.resolve()) or path == root.resolve():
-        raise ValueError(f"Path outside source root: {relative}")
-    return path
-
-
-def load_plan(manifest, source_root):
-    import pyarrow.parquet as pq
-
-    suite = manifest.get("suite", "Order")
-    if suite not in {"Order", "State"}:
-        raise ValueError("Expected Order or State suite")
-    prefix = "O" if suite == "Order" else "S"
-    plan, ids, sources_seen = [], set(), set()
-    for task in manifest["tasks"]:
-        if not re.fullmatch(prefix + r"\d{2,}", task["task_id"]) or not re.fullmatch(r"[a-z0-9_]+", task["task_slug"]):
-            raise ValueError(f"Invalid {suite} task ID/slug")
-        if task["task_id"] in ids:
-            raise ValueError("Duplicate task ID")
-        ids.add(task["task_id"])
-        episodes, snapshots = [], {}
-        for source in task["sources"]:
-            name = source["dataset"]
-            if name in sources_seen:
-                raise ValueError(f"Duplicate source dataset: {name}")
-            sources_seen.add(name)
-            root = child(source_root, name)
-            info_path = root / "meta/info.json"
-            info = json.loads(info_path.read_text())
-            if info["codebase_version"] != "v3.0" or info["total_episodes"] != source["episodes"]:
-                raise ValueError(f"Source version/count changed: {name}")
-            if info["total_episodes"] <= 0 or info["fps"] <= 0:
-                raise ValueError(f"Empty/invalid source: {name}")
-            if any(info["features"].get(camera, {}).get("dtype") != "video" for camera in CAMERAS.values()):
-                raise ValueError(f"Missing configured three-view cameras: {name}")
-            meta_files = [info_path] + sorted((root / "meta/episodes").rglob("*.parquet"))
-            rows = [row for p in meta_files[1:] for row in pq.read_table(p).to_pylist()]
-            rows.sort(key=lambda row: row["episode_index"])
-            if [r["episode_index"] for r in rows] != list(range(source["episodes"])):
-                raise ValueError(f"Noncontiguous or unfinished episode metadata: {name}")
-            if sum(r["length"] for r in rows) != info["total_frames"]:
-                raise ValueError(f"Source frame total mismatch: {name}")
-            excluded = source.get("exclude_episodes", [])
-            if len(set(excluded)) != len(excluded) or not set(excluded).issubset(range(source["episodes"])):
-                raise ValueError(f"Invalid explicit episode exclusions: {name}")
-            snapshots.update({str(p): sha256(p) for p in meta_files})
-            for row in rows:
-                if row["episode_index"] in excluded:
-                    continue
-                instructions = row["tasks"]
-                if len(instructions) != 1 or not instructions[0].strip() or row["length"] <= 0:
-                    raise ValueError(f"Expected one nonempty instruction per episode: {name}")
-                views = {}
-                for view, camera in CAMERAS.items():
-                    prefix = f"videos/{camera}"
-                    start = row[prefix + "/from_timestamp"] * info["fps"]
-                    end = row[prefix + "/to_timestamp"] * info["fps"]
-                    if abs(start - round(start)) > 0.01 or abs(end - start - row["length"]) > 0.01:
-                        raise ValueError(f"Non-frame-aligned range: {name}, {row['episode_index']}, {view}")
-                    relative = info["video_path"].format(
-                        video_key=camera, chunk_index=row[prefix + "/chunk_index"],
-                        file_index=row[prefix + "/file_index"])
-                    path = child(root, relative)
-                    if not path.is_file():
-                        raise ValueError(f"Missing video: {path}")
-                    views[view] = dict(path=path, source_path=f"{name}/{relative}", start=round(start))
-                episodes.append(dict(source_dataset=name, source_episode=row["episode_index"],
-                                     instruction=instructions[0], frames=row["length"],
-                                     fps=info["fps"], views=views))
-        median = statistics.median(e["frames"] / e["fps"] for e in episodes)
-        warnings = [dict(dataset=e["source_dataset"], episode=e["source_episode"],
-                         duration_s=e["frames"] / e["fps"], reason="less than 60% of task median; review only")
-                    for e in episodes if e["frames"] / e["fps"] < median * 0.6]
-        plan.append(dict(task=task, episodes=episodes, snapshots=snapshots, warnings=warnings))
-    return plan
-
-
-def try_remux(source, target, start, count, fps):
-    """Accept stream-copy cuts only after a complete frame/pixel comparison."""
-    import av
-
-    rate = Fraction(fps).limit_denominator()
-    with av.open(str(source)) as inp:
-        video = inp.streams.video[0]
-        if video.codec_context.name != "h264" or video.average_rate != rate:
-            return None
-        origin = (video.start_time or 0) * video.time_base
-        inp.seek(int((origin + Fraction(start, 1) / rate) / video.time_base), stream=video, backward=True)
-        expected, n = hashlib.sha256(), 0
-        for frame in inp.decode(video=0):
-            if frame.pts is None:
-                return None
-            position = (frame.pts * frame.time_base - origin) * rate
-            index = round(position)
-            if index < start:
-                continue
-            if index >= start + count:
-                break
-            if abs(position - index) > .01 or index != start + n:
-                return None
-            expected.update(frame.to_ndarray(format="yuv420p").tobytes())
-            n += 1
-    if n != count:
-        return None
-    result = subprocess.run(["ffmpeg", "-v", "error", "-nostdin", "-y", "-ss", str(float(start / rate)),
-                             "-i", str(source), "-frames:v", str(count), "-map", "0:v:0", "-an",
-                             "-c:v", "copy", "-movflags", "+faststart", str(target)], capture_output=True)
-    matched, digest, n = result.returncode == 0, hashlib.sha256(), 0
-    if matched:
-        try:
-            with av.open(str(target)) as inp:
-                matched = inp.streams.video[0].average_rate == rate
-                for frame in inp.decode(video=0):
-                    if frame.pts is None or abs(frame.pts * frame.time_base - n / rate) > Fraction(1, 10000):
-                        matched = False
-                    digest.update(frame.to_ndarray(format="yuv420p").tobytes())
-                    n += 1
-        except av.FFmpegError:
-            matched = False
-    if matched and n == count and digest.digest() == expected.digest():
-        return dict(video_size_bytes=target.stat().st_size, video_sha256=sha256(target),
-                    decoded_yuv_sha256=digest.hexdigest(), video_processing="frame_exact_lossless_h264_remux")
-    target.unlink(missing_ok=True)
-    return None
-
-
-def export_clip(source, target, start, count, fps, preset="ultrafast", remux_first=False):
-    """Decode from the preceding keyframe, cut exact frames, encode losslessly."""
-    import av
-
-    if remux_first:
-        result = try_remux(source, target, start, count, fps)
-        if result is not None:
-            return result
-    rate = Fraction(fps).limit_denominator()
-    digest, written = hashlib.sha256(), 0
-    with av.open(str(source)) as inp, av.open(str(target), "w") as out:
-        video = inp.streams.video[0]
-        if video.average_rate != rate or video.codec_context.pix_fmt != "yuv420p":
-            raise ValueError(f"Expected CFR yuv420p source at {fps} FPS: {source}")
-        origin = (video.start_time or 0) * video.time_base
-        stream = out.add_stream("libx264", rate=rate, options={"crf": "0", "preset": preset})
-        stream.width, stream.height = video.width, video.height
-        stream.pix_fmt = "yuv420p"
-        stream.codec_context.thread_count = 2
-        stream.time_base = 1 / rate
-        inp.seek(int((origin + Fraction(start, 1) / rate) / video.time_base), stream=video, backward=True)
-        for frame in inp.decode(video=0):
-            if frame.pts is None:
-                raise ValueError("Source frame has no PTS")
-            position = (frame.pts * frame.time_base - origin) * rate
-            index = round(position)
-            if abs(position - index) > 0.01:
-                raise ValueError("Nonuniform source video timestamps")
-            if index < start:
-                continue
-            if index >= start + count:
-                break
-            if index != start + written:
-                raise ValueError(f"Missing/duplicate source frame: {source}, {index}")
-            digest.update(frame.to_ndarray(format="yuv420p").tobytes())
-            frame.pts, frame.time_base = written, 1 / rate
-            for packet in stream.encode(frame):
-                out.mux(packet)
-            written += 1
-        for packet in stream.encode():
-            out.mux(packet)
-    if written != count:
-        raise ValueError(f"Truncated source clip: {source}, wanted {count}, got {written}")
-    check, decoded = hashlib.sha256(), 0
-    with av.open(str(target)) as inp:
-        for frame in inp.decode(video=0):
-            if frame.pts is None or abs(frame.pts * frame.time_base - decoded / rate) > Fraction(1, 10000):
-                raise ValueError(f"Output timestamp mismatch: {target}")
-            check.update(frame.to_ndarray(format="yuv420p").tobytes())
-            decoded += 1
-    if decoded != count or check.digest() != digest.digest():
-        raise ValueError(f"Output frame count/pixel mismatch: {target}")
-    return dict(video_size_bytes=target.stat().st_size, video_sha256=sha256(target),
-                decoded_yuv_sha256=check.hexdigest(), video_processing="frame_exact_lossless_h264")
-
-
-def convert(plan, manifest, output, limit=None):
-    suite = manifest.get("suite", "Order")
-    output.mkdir(parents=True, exist_ok=False)
-    write_json(output / "export-status.json", {"status": "incomplete"})
-    write_json(output / "source-manifest.json", manifest)
-    hashes, stats, mapping, split_tasks = {}, [], [], []
-    for item in plan:
-        task = item["task"]
-        folder = f"{task['task_id'][1:]}-{task['task_slug']}"
-        target = output / suite / folder
-        target.mkdir(parents=True)
-        (target / "annotations").mkdir()
-        episodes = item["episodes"][:limit] if limit else item["episodes"]
-        rows = []
-        for index, episode in enumerate(episodes):
-            views = {}
-            for view, source in episode["views"].items():
-                path = target / "videos" / view / f"episode_{index:06d}.mp4"
-                path.parent.mkdir(parents=True, exist_ok=True)
-                raw = source["path"]
-                if raw not in hashes:
-                    hashes[raw] = (sha256(raw), raw.stat())
-                details = export_clip(raw, path, source["start"], episode["frames"], episode["fps"],
-                                      preset=manifest.get("video_preset", "ultrafast"),
-                                      remux_first=manifest.get("video_remux_first", False))
-                views[view] = dict(camera=CAMERAS[view], video_path=path.relative_to(target).as_posix(),
-                                   source_path=source["source_path"], source_sha256=hashes[raw][0],
-                                   **{k: v for k, v in details.items() if k != "decoded_yuv_sha256"})
-                mapping.append(dict(sample_id=f"evomind_{task['task_id']}_episode_{index:06d}",
-                                    source_dataset=episode["source_dataset"], source_episode=episode["source_episode"],
-                                    view=view, source_start_frame=source["start"], frames=episode["frames"], **details))
-            main = views["main_view"]
-            row = dict(sample_id=f"evomind_{task['task_id']}_episode_{index:06d}",
-                       task_id=task["task_id"], task_name=task["task_name"], task_slug=task["task_slug"],
-                       domain="real-world", episode_index=index, video_path=main["video_path"],
-                       annotation_path=None, has_annotation=False, task_prompt=None,
-                       source_instruction=episode["instruction"], fps=episode["fps"], total_frames=episode["frames"],
-                       num_stages=None, annotation_sha256=None, video_size_bytes=main["video_size_bytes"],
-                       video_sha256=main["video_sha256"], source_path=main["source_path"],
-                       source_total_frames=episode["frames"], source_sha256=main["source_sha256"],
-                       video_processing=main["video_processing"], source_repo=None, source_revision=None,
-                       video_views=views, suite=suite, source_dataset="EvoMind-PiperX",
-                       source_sample_id=f"{episode['source_dataset']}/episode_{episode['source_episode']:06d}",
-                       source_dataset_video_path=main["source_path"], collection_task_id=task["collection_task_id"],
-                       collection_task_name=task["collection_task_name"], collection_task_slug=task["task_slug"],
-                       source_collection="EvoMind", source_dataset_url=None,
-                       source_task_id=task["collection_task_id"], source_task_name=episode["instruction"],
-                       source_task_url=None, name_evidence="recorded_lerobot_episode_instruction", source_file_url=None)
-            rows.append(row)
-            print(f"{task['task_id']} episode {index + 1}/{len(episodes)} verified", flush=True)
-        for path, digest in item["snapshots"].items():
-            if sha256(path) != digest:
-                raise ValueError(f"Source metadata changed during export: {path}")
-        summary = dict(task_id=task["task_id"], task_name=task["task_name"], path=".",
-                       task_slug=task["task_slug"], suite=suite, domain="real-world",
-                       domain_counts={"real-world": len(rows)}, source_dataset="EvoMind-PiperX",
-                       source_repositories=[], source_revisions=[], source_collection="EvoMind",
-                       collection_task_id=task["collection_task_id"], collection_task_names=[task["collection_task_name"]],
-                       trajectory_count=len(rows), annotated_trajectory_count=0, unannotated_trajectory_count=len(rows),
-                       view_trajectory_counts={view: len(rows) for view in CAMERAS},
-                       video_file_count=len(rows) * 3, annotation_file_count=0, trajectory_index="metadata.jsonl",
-                       classification_basis=f"User classified these recordings as {suite} tasks.",
-                       format_reference={"repository": manifest["format_reference"], "revision": manifest["format_revision"]},
-                       source_datasets=[source["dataset"] for source in task["sources"]],
-                       annotation_status="No stage labels collected; pending annotation.")
-        write_json(target / "metadata.json", summary)
-        index_path = target / "metadata.jsonl"
-        index_path.write_text("".join(json.dumps(r, ensure_ascii=False) + "\n" for r in rows), encoding="utf-8")
-        validation_count = math.ceil(len(rows) * 0.2)
-        sample_ids = [row["sample_id"] for row in rows]
-        split_tasks.append(dict(suite=suite, task_id=task["task_id"], task_name=task["task_name"],
-                                task_path=f"{suite}/{folder}", trajectory_index=f"{suite}/{folder}/metadata.jsonl",
-                                trajectory_index_sha256=sha256(index_path),
-                                train=sample_ids[:-validation_count], val=sample_ids[-validation_count:]))
-        stats.append(dict(task_id=task["task_id"], directory=f"{suite}/{folder}", episodes=len(rows),
-                          frames=sum(e["frames"] for e in episodes), warnings=item["warnings"]))
-    for path, (digest, before) in hashes.items():
-        after = path.stat()
-        if (after.st_size, after.st_mtime_ns) != (before.st_size, before.st_mtime_ns):
-            raise ValueError(f"Source video changed during export: {path}")
-    write_json(output / "provenance.json", dict(tool_sha256=sha256(__file__), trajectories=mapping,
-                                               source_metadata_sha256={p: h for t in plan for p, h in t["snapshots"].items()}))
-    write_json(output / "manifest.additions.json", dict(
-        schema_version=1, partial=bool(limit), base_revision=manifest["format_revision"],
-        note="New tasks only; merge explicitly into the HF manifest without changing existing frozen splits.",
-        split_policy={"unit": "trajectory", "val_fraction": 0.2,
-                      "selection": "last ceil(n * 0.2) trajectories are val; preceding trajectories are train",
-                      "include_unannotated": True, "path_base": "manifest directory", "frozen": True},
-        tasks=split_tasks))
-    report = dict(status="passed", partial=bool(limit), tasks=stats,
-                  episodes=sum(t["episodes"] for t in stats), videos=sum(t["episodes"] * 3 for t in stats),
-                  checks="Full output decode; frame counts, timestamps and decoded YUV equality to source cuts; source metadata hashes.")
-    write_json(output / "export-status.json", report)
-    (output / suite / "README.md").write_text(
-        f"# {suite} — EvoMind recordings\n\nUnannotated real robot recordings. "
-        "Each task has metadata.json and metadata.jsonl with task-relative paths. "
-        "main_view is the environment camera; left_view/right_view are wrist cameras. "
-        "Stage annotations have not been collected. See ../export-status.json and ../provenance.json.\n\n"
-        + "\n".join(f"- [{t['task_id']}]({t['directory'].split('/', 1)[1]}/): {t['episodes']} trajectories" for t in stats) + "\n")
-    return report
-
-
-def main():
-    p = argparse.ArgumentParser(description=__doc__)
-    p.add_argument("--manifest", type=Path, default=Path(__file__).with_name("order_20261031.json"))
-    p.add_argument("--source-root", type=Path, required=True)
-    p.add_argument("--output", type=Path)
-    p.add_argument("--plan", action="store_true", help="Validate metadata and report short clips without writing output")
-    p.add_argument("--limit-per-task", type=int, help="Export a partial smoke test, never a complete release")
-    args = p.parse_args()
-    if args.limit_per_task is not None and args.limit_per_task < 1:
-        p.error("--limit-per-task must be positive")
-    if not args.plan and args.output is None:
-        p.error("--output is required unless --plan is set")
-    manifest = json.loads(args.manifest.read_text())
-    plan = load_plan(manifest, args.source_root.resolve())
-    if args.plan:
-        report = dict(episodes=sum(len(t["episodes"]) for t in plan), tasks=[
-            dict(task_id=t["task"]["task_id"], name=t["task"]["collection_task_name"],
-                 episodes=len(t["episodes"]), warnings=t["warnings"]) for t in plan])
-    else:
-        output = args.output.resolve()
-        if output.is_relative_to(args.source_root.resolve()) or args.source_root.resolve().is_relative_to(output):
-            p.error("Output must be separate from the source data tree")
-        report = convert(plan, manifest, output, args.limit_per_task)
-    print(json.dumps(report, ensure_ascii=False, indent=2))
-
-
-if __name__ == "__main__":
-    main()

provenance/evomind-state-20261102/prepare_personal_state.py

@@ -1,130 +0,0 @@
-"""Prepare a standalone personal State dataset from the validated release."""
-import copy
-from datetime import datetime, timezone, timedelta
-import hashlib
-import json
-import os
-from pathlib import Path
-import shutil
-
-SOURCE = Path('/home/zhaobo/work/codex_active_vision/proprimem_state_export_20261102_v001')
-ROOT = Path('/home/zhaobo/work/codex_active_vision/proprimem_state_personal_20261103_v001')
-REPO = 'syding9/ProPriMem-State'
-
-
-def read(path):
-    return json.loads(path.read_text())
-
-
-def write(path, value):
-    path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + '\n')
-
-
-def copy_file(source, target):
-    if Path(source).suffix == '.mp4':
-        os.link(source, target)
-    else:
-        shutil.copy2(source, target)
-    return target
-
-
-if __name__ == '__main__':
-    report = read(SOURCE / 'full/export-status.json')
-    assert report['status'] == 'passed' and not report['partial']
-    assert report['episodes'] == 186 and report['videos'] == 558
-    ROOT.mkdir(exist_ok=False)
-    full = ROOT / 'full'
-    full.mkdir()
-    (ROOT / 'tools').mkdir()
-    shutil.copytree(SOURCE / 'full/State', full / 'State', copy_function=copy_file)
-    shutil.copytree(SOURCE / 'full/provenance', full / 'provenance')
-    evidence = full / 'provenance/evomind-state-20261102'
-    # This script replaces the organization-specific publication preparation.
-    (evidence / 'prepare_state_pr.py').unlink()
-    for name in ['source-manifest.json', 'export-status.json', 'provenance.json', 'manifest.additions.json']:
-        shutil.copy2(SOURCE / 'full' / name, full / name)
-    old = read(SOURCE / 'full/manifest.json')
-    tasks = [t for t in old['tasks'] if t['task_id'] in {'S11', 'S12', 'S13', 'S14', 'S15'}]
-    assert len(tasks) == 5
-    manifest = dict(schema_version=old['schema_version'], split_policy=copy.deepcopy(old['split_policy']),
-                    dataset_version='1.0.0', split_version='1.0.0',
-                    created_at=datetime.now(timezone(timedelta(hours=8))).isoformat(),
-                    summary={'State': {'tasks': 5, 'train': 148, 'val': 38}},
-                    totals={'tasks': 5, 'trajectories': 186, 'train': 148, 'val': 38}, tasks=tasks,
-                    source_format_reference=read(full / 'source-manifest.json')['format_reference'])
-    write(full / 'manifest.json', manifest)
-    rows = []
-    for task in tasks:
-        index = full / task['trajectory_index']
-        assert hashlib.sha256(index.read_bytes()).hexdigest() == task['trajectory_index_sha256']
-        data = [json.loads(line) for line in index.read_text().splitlines()]
-        assert [r['sample_id'] for r in data] == task['train'] + task['val']
-        assert task['suite'] == 'State' and not task['task_name'].startswith('State:')
-        rows.append(f"| {task['task_id']} | [{task['task_name']}]({task['task_path']}/) | {len(data)} |")
-        for row in data:
-            assert not row['has_annotation'] and row['annotation_path'] is None
-            for view in row['video_views'].values():
-                path = index.parent / view['video_path']
-                original = SOURCE / 'full' / path.relative_to(full)
-                assert path.stat().st_ino == original.stat().st_ino
-                assert path.stat().st_size == view['video_size_bytes']
-    table = '| ID | Task | Trajectories |\n|---|---|---:|\n' + '\n'.join(rows)
-    readme = '''---
-pretty_name: ProPriMem-State
-tags:
-  - robotics
-  - memory
-  - state
----
-# ProPriMem-State
-
-5 real-robot State tasks · 186 trajectories · 558 videos.
-
-Recorded using a bimanual PiperX setup on 2026-10-31 and 2026-11-02. Each trajectory contains
-an environment camera (`main_view`) and two wrist cameras (`left_view`, `right_view`), at
-1280×720 and 30 FPS. This dataset follows the task-directory and index format of
-[MINT-SJTU/ProPriMem](https://huggingface.co/datasets/MINT-SJTU/ProPriMem).
-
-TABLE
-
-## Format and splits
-
-Each task in `State/` contains `metadata.json`, `metadata.jsonl` and `videos/`.
-Paths within a trajectory index are relative to its task directory. Task identifiers S11–S15
-are retained for compatibility with the prepared ProPriMem State addition; this standalone
-repository contains only these five tasks.
-
-Dataset v1.0.0 · Split v1.0.0 · **148 train / 38 val**. Explicit trajectory assignments in
-[manifest.json](manifest.json) are frozen; all views of a trajectory share its split.
-
-These recordings are **unannotated**: `has_annotation=false`; stage boundaries and task-success
-labels are not inferred. Recorded instructions remain in `source_instruction`. Task names do
-not have a `State:` prefix. Raw robot state/action Parquet files are not included.
-
-## Selection and validation
-
-Six user-reviewed abnormal piggy-bank episodes are excluded: batch `20261031_153227` #3, #15,
-#16; batch `20261031_161309` #18, #19, #20. The original raw recordings are retained separately.
-The test-tube task combines three valid batches (11 + 3 + 35 trajectories).
-
-All 558 videos are frame-exact H.264 stream-copy cuts. Full decoding confirmed frame counts,
-timestamps and equality of decoded YUV pixels to the original source cuts. Eight conversion
-tests passed. Source selection, mappings and validation records are under
-[`provenance/evomind-state-20261102/`](provenance/evomind-state-20261102/).
-'''.replace('TABLE', table)
-    (full / 'README.md').write_text(readme)
-    state_table = table.replace('](State/', '](')
-    (full / 'State/README.md').write_text('# State\n\n5 tasks · 186 trajectories.\n\n' + state_table + '\n')
-    write(evidence / 'publication.json', dict(repository=REPO, dataset_version='1.0.0',
-          trajectories=186, videos=558, train=148, val=38, original_raw_data_retained=True))
-    shutil.copy2(__file__, evidence / Path(__file__).name)
-    files = sorted(p for p in full.rglob('*') if p.is_file() and
-                   (p.relative_to(full).parts[0] in ['State', 'provenance'] or
-                    p.relative_to(full).as_posix() in ['README.md', 'manifest.json']))
-    assert sum(p.suffix == '.mp4' for p in files) == 558
-    receipt = dict(repository=REPO, private=True, files=len(files), videos=558, trajectories=186,
-                   bytes=sum(p.stat().st_size for p in files),
-                   paths=[p.relative_to(full).as_posix() for p in files],
-                   totals=manifest['totals'], splits_preserved=True)
-    write(ROOT / 'preparation.json', receipt)
-    print(json.dumps({k:v for k,v in receipt.items() if k != 'paths'}, indent=2), flush=True)

provenance/evomind-state-20261102/publication.json

@@ -1,9 +0,0 @@
-{
-  "repository": "syding9/ProPriMem-State",
-  "dataset_version": "1.0.0",
-  "trajectories": 186,
-  "videos": 558,
-  "train": 148,
-  "val": 38,
-  "original_raw_data_retained": true
-}

provenance/evomind-state-20261102/review-approved.json

@@ -1,58 +0,0 @@
-{
-  "original_count": 192,
-  "recommended_exclusions": [
-    {
-      "dataset": "State: 存钱罐里放3个硬币_40dcb735_20261031_153227",
-      "episode": 3,
-      "duration_s": 16.0,
-      "recommendation": "建议排除（尚未删除）",
-      "review_reason": "0.5 秒间隔画面显示始终在硬币堆附近抓取，未见向存钱罐投币；16 秒，任务中位数约 30.3 秒。",
-      "export_decision": "exclude"
-    },
-    {
-      "dataset": "State: 存钱罐里放3个硬币_40dcb735_20261031_153227",
-      "episode": 15,
-      "duration_s": 119.46666666666667,
-      "recommendation": "建议排除（尚未删除）",
-      "review_reason": "约 120 秒，抽帧以空等/收尾调整为主；两侧夹爪动作值全程恒定，未见执行三次投币。",
-      "export_decision": "exclude"
-    },
-    {
-      "dataset": "State: 存钱罐里放3个硬币_40dcb735_20261031_153227",
-      "episode": 16,
-      "duration_s": 119.53333333333333,
-      "recommendation": "建议排除（尚未删除）",
-      "review_reason": "约 120 秒，抽帧以空等/收尾调整为主；两侧夹爪动作值全程恒定，未见执行三次投币。",
-      "export_decision": "exclude"
-    },
-    {
-      "dataset": "State: 存钱罐里放3个硬币_40dcb735_20261031_161309",
-      "episode": 18,
-      "duration_s": 119.46666666666667,
-      "recommendation": "建议排除（尚未删除）",
-      "review_reason": "约 120 秒，抽帧以空等/收尾调整为主；两侧夹爪动作值全程恒定，未见执行三次投币。",
-      "export_decision": "exclude"
-    },
-    {
-      "dataset": "State: 存钱罐里放3个硬币_40dcb735_20261031_161309",
-      "episode": 19,
-      "duration_s": 119.53333333333333,
-      "recommendation": "建议排除（尚未删除）",
-      "review_reason": "约 120 秒，抽帧以空等/收尾调整为主；两侧夹爪动作值全程恒定，未见执行三次投币。",
-      "export_decision": "exclude"
-    },
-    {
-      "dataset": "State: 存钱罐里放3个硬币_40dcb735_20261031_161309",
-      "episode": 20,
-      "duration_s": 119.56666666666666,
-      "recommendation": "建议排除（尚未删除）",
-      "review_reason": "约 120 秒，抽帧以空等/收尾调整为主；两侧夹爪动作值全程恒定，未见执行三次投币。",
-      "export_decision": "exclude"
-    }
-  ],
-  "remaining_if_approved": 186,
-  "raw_data_modified": false,
-  "uploaded": false,
-  "approved_by_user_on": "2026-11-02",
-  "selection_status": "approved_and_excluded_from_export"
-}

provenance/evomind-state-20261102/run_state_export.py

@@ -1,51 +0,0 @@
-"""Convert the approved five State tasks in parallel and assemble one release."""
-from concurrent.futures import ProcessPoolExecutor
-import json
-from pathlib import Path
-import shutil
-
-import export_order as exporter
-
-ROOT = Path(__file__).resolve().parent.parent
-RAW = Path('/home/zhaobo/work/codex_active_vision/memory_depend_collection_20261030_v001/data')
-MANIFEST = json.loads((ROOT / 'tools/state_20261102.json').read_text())
-
-
-def run(task):
-    manifest = dict(MANIFEST, tasks=[task])
-    out = ROOT / 'parts' / task['task_id']
-    status = out / 'export-status.json'
-    if status.exists() and json.loads(status.read_text()).get('status') == 'passed':
-        return out
-    plan = exporter.load_plan(manifest, RAW)
-    result = exporter.convert(plan, manifest, out)
-    print('FINISHED', task['task_id'], result['episodes'], flush=True)
-    return out
-
-
-if __name__ == '__main__':
-    with ProcessPoolExecutor(max_workers=4) as pool:
-        parts = list(pool.map(run, MANIFEST['tasks']))
-    full = ROOT / 'full'
-    full.mkdir()
-    (full / 'State').mkdir()
-    reports = [json.loads((p / 'export-status.json').read_text()) for p in parts]
-    assert all(p['status'] == 'passed' and not p['partial'] for p in reports)
-    for part in parts:
-        for folder in (part / 'State').iterdir():
-            if folder.is_dir():
-                shutil.move(str(folder), full / 'State' / folder.name)
-    provenance = [json.loads((p / 'provenance.json').read_text()) for p in parts]
-    assert len({p['tool_sha256'] for p in provenance}) == 1
-    exporter.write_json(full / 'source-manifest.json', MANIFEST)
-    exporter.write_json(full / 'provenance.json', dict(tool_sha256=provenance[0]['tool_sha256'],
-        trajectories=[r for p in provenance for r in p['trajectories']],
-        source_metadata_sha256={k:v for p in provenance for k,v in p['source_metadata_sha256'].items()}))
-    additions = [json.loads((p / 'manifest.additions.json').read_text()) for p in parts]
-    exporter.write_json(full / 'manifest.additions.json', dict(additions[0], tasks=[t for p in additions for t in p['tasks']]))
-    report = dict(status='passed', partial=False, tasks=[t for p in reports for t in p['tasks']],
-                  episodes=sum(p['episodes'] for p in reports), videos=sum(p['videos'] for p in reports),
-                  checks=reports[0]['checks'])
-    assert report['episodes'] == 186 and report['videos'] == 558
-    exporter.write_json(full / 'export-status.json', report)
-    print('FULL DONE', report['episodes'], report['videos'], flush=True)

provenance/evomind-state-20261102/source-manifest.json

@@ -1,100 +0,0 @@
-{
-  "format_reference": "MINT-SJTU/ProPriMem",
-  "format_revision": "9afafe07bba3714ee86bde12834f6033e9685ac8",
-  "suite": "State",
-  "video_preset": "medium",
-  "tasks": [
-    {
-      "task_id": "S11",
-      "task_slug": "put_three_coins_into_piggy_bank",
-      "task_name": "Put three coins into a piggy bank",
-      "collection_task_id": "40dcb735-6a97-4e74-b19e-9d1133bfb7c0",
-      "collection_task_name": "存钱罐里放3个硬币",
-      "sources": [
-        {
-          "dataset": "State: 存钱罐里放3个硬币_40dcb735_20261031_153227",
-          "episodes": 17,
-          "exclude_episodes": [
-            3,
-            15,
-            16
-          ]
-        },
-        {
-          "dataset": "State: 存钱罐里放3个硬币_40dcb735_20261031_161309",
-          "episodes": 21,
-          "exclude_episodes": [
-            18,
-            19,
-            20
-          ]
-        }
-      ]
-    },
-    {
-      "task_id": "S12",
-      "task_slug": "inspect_four_objects_and_return",
-      "task_name": "Inspect four objects and return them",
-      "collection_task_id": "c140db97-8fc7-46b2-9624-7b6ee5b92956",
-      "collection_task_name": "检测4个物品并放回原位",
-      "sources": [
-        {
-          "dataset": "State-检测-4-个物品并放回原位_c140db97_20261102_153040",
-          "episodes": 35
-        }
-      ]
-    },
-    {
-      "task_id": "S13",
-      "task_slug": "inspect_three_drawers",
-      "task_name": "Inspect three drawers",
-      "collection_task_id": "d0d3e517-daaf-44b7-aa97-554622c46ed0",
-      "collection_task_name": "巡检抽屉",
-      "sources": [
-        {
-          "dataset": "State-巡检抽屉_d0d3e517_20261102_164828",
-          "episodes": 35
-        }
-      ]
-    },
-    {
-      "task_id": "S14",
-      "task_slug": "weigh_four_objects_and_return",
-      "task_name": "Weigh four objects and return them",
-      "collection_task_id": "58fcd50b-3cc0-44a7-84e5-3f19e495f592",
-      "collection_task_name": "称重归位",
-      "sources": [
-        {
-          "dataset": "State-称重归位_58fcd50b_20261102_171751",
-          "episodes": 35
-        }
-      ]
-    },
-    {
-      "task_id": "S15",
-      "task_slug": "inspect_three_test_tubes",
-      "task_name": "Inspect three test tubes",
-      "collection_task_id": "1b7e5920-8114-4da2-9377-a94c23eca638",
-      "collection_task_name": "试管架",
-      "sources": [
-        {
-          "dataset": "State-试管架_1b7e5920_20261102_190333",
-          "episodes": 11
-        },
-        {
-          "dataset": "State-试管架_1b7e5920_20261102_191341",
-          "episodes": 3
-        },
-        {
-          "dataset": "State-试管架_1b7e5920_20261102_204939",
-          "episodes": 35
-        }
-      ]
-    }
-  ],
-  "selection_note": "User-approved exclusions: six reviewed piggy-bank episodes; all other selected saved episodes retained. Raw data unchanged.",
-  "reviewed_source_episodes": 192,
-  "excluded_episodes": 6,
-  "expected_episodes": 186,
-  "video_remux_first": true
-}

provenance/evomind-state-20261102/state_20261102.json

@@ -1,100 +0,0 @@
-{
-  "format_reference": "MINT-SJTU/ProPriMem",
-  "format_revision": "9afafe07bba3714ee86bde12834f6033e9685ac8",
-  "suite": "State",
-  "video_preset": "medium",
-  "tasks": [
-    {
-      "task_id": "S11",
-      "task_slug": "put_three_coins_into_piggy_bank",
-      "task_name": "Put three coins into a piggy bank",
-      "collection_task_id": "40dcb735-6a97-4e74-b19e-9d1133bfb7c0",
-      "collection_task_name": "存钱罐里放3个硬币",
-      "sources": [
-        {
-          "dataset": "State: 存钱罐里放3个硬币_40dcb735_20261031_153227",
-          "episodes": 17,
-          "exclude_episodes": [
-            3,
-            15,
-            16
-          ]
-        },
-        {
-          "dataset": "State: 存钱罐里放3个硬币_40dcb735_20261031_161309",
-          "episodes": 21,
-          "exclude_episodes": [
-            18,
-            19,
-            20
-          ]
-        }
-      ]
-    },
-    {
-      "task_id": "S12",
-      "task_slug": "inspect_four_objects_and_return",
-      "task_name": "Inspect four objects and return them",
-      "collection_task_id": "c140db97-8fc7-46b2-9624-7b6ee5b92956",
-      "collection_task_name": "检测4个物品并放回原位",
-      "sources": [
-        {
-          "dataset": "State-检测-4-个物品并放回原位_c140db97_20261102_153040",
-          "episodes": 35
-        }
-      ]
-    },
-    {
-      "task_id": "S13",
-      "task_slug": "inspect_three_drawers",
-      "task_name": "Inspect three drawers",
-      "collection_task_id": "d0d3e517-daaf-44b7-aa97-554622c46ed0",
-      "collection_task_name": "巡检抽屉",
-      "sources": [
-        {
-          "dataset": "State-巡检抽屉_d0d3e517_20261102_164828",
-          "episodes": 35
-        }
-      ]
-    },
-    {
-      "task_id": "S14",
-      "task_slug": "weigh_four_objects_and_return",
-      "task_name": "Weigh four objects and return them",
-      "collection_task_id": "58fcd50b-3cc0-44a7-84e5-3f19e495f592",
-      "collection_task_name": "称重归位",
-      "sources": [
-        {
-          "dataset": "State-称重归位_58fcd50b_20261102_171751",
-          "episodes": 35
-        }
-      ]
-    },
-    {
-      "task_id": "S15",
-      "task_slug": "inspect_three_test_tubes",
-      "task_name": "Inspect three test tubes",
-      "collection_task_id": "1b7e5920-8114-4da2-9377-a94c23eca638",
-      "collection_task_name": "试管架",
-      "sources": [
-        {
-          "dataset": "State-试管架_1b7e5920_20261102_190333",
-          "episodes": 11
-        },
-        {
-          "dataset": "State-试管架_1b7e5920_20261102_191341",
-          "episodes": 3
-        },
-        {
-          "dataset": "State-试管架_1b7e5920_20261102_204939",
-          "episodes": 35
-        }
-      ]
-    }
-  ],
-  "selection_note": "User-approved exclusions: six reviewed piggy-bank episodes; all other selected saved episodes retained. Raw data unchanged.",
-  "reviewed_source_episodes": 192,
-  "excluded_episodes": 6,
-  "expected_episodes": 186,
-  "video_remux_first": true
-}

provenance/evomind-state-20261102/test_export_order.py

@@ -1,180 +0,0 @@
-import copy
-from fractions import Fraction
-import hashlib
-import json
-from pathlib import Path
-import tempfile
-import unittest
-
-import av
-import numpy as np
-import pyarrow as pa
-import pyarrow.parquet as pq
-
-import export_order as exporter
-
-
-class ExportTests(unittest.TestCase):
-    def setUp(self):
-        self.tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self.tmp.cleanup)
-        self.root = Path(self.tmp.name)
-        self.source = self.root / "raw"
-        dataset = self.source / "recording"
-        (dataset / "meta/episodes/chunk-000").mkdir(parents=True)
-        self.info = dict(codebase_version="v3.0", total_episodes=2, total_frames=20, fps=30,
-                         features={c: {"dtype": "video"} for c in exporter.CAMERAS.values()},
-                         video_path="videos/{video_key}/chunk-{chunk_index:03d}/file-{file_index:03d}.mp4")
-        self.manifest = dict(format_reference="MINT-SJTU/ProPriMem", format_revision="test", tasks=[
-            dict(task_id="O08", task_slug="test_sequence", task_name="Test sequence",
-                 collection_task_id="local-id", collection_task_name="测试", sources=[
-                     dict(dataset="recording", episodes=2)])])
-        rows = []
-        for i, (start, length) in enumerate([(0, 7), (7, 13)]):
-            row = dict(episode_index=i, length=length, tasks=["Press one, then three"])
-            for camera in exporter.CAMERAS.values():
-                prefix = f"videos/{camera}"
-                row.update({prefix + "/chunk_index": 0, prefix + "/file_index": 0,
-                            prefix + "/from_timestamp": start / 30,
-                            prefix + "/to_timestamp": (start + length) / 30})
-            rows.append(row)
-        exporter.write_json(dataset / "meta/info.json", self.info)
-        pq.write_table(pa.Table.from_pylist(rows), dataset / "meta/episodes/chunk-000/file-000.parquet")
-        for camera in exporter.CAMERAS.values():
-            path = dataset / f"videos/{camera}/chunk-000/file-000.mp4"
-            path.parent.mkdir(parents=True)
-            with av.open(str(path), "w") as out:
-                stream = out.add_stream("libx264", rate=30, options={"g": "12", "crf": "0"})
-                stream.width, stream.height, stream.pix_fmt = 32, 24, "yuv420p"
-                for i in range(20):
-                    pixels = np.full((24, 32, 3), (i * 11) % 256, dtype=np.uint8)
-                    frame = av.VideoFrame.from_ndarray(pixels, format="rgb24")
-                    frame.pts, frame.time_base = i, Fraction(1, 30)
-                    for packet in stream.encode(frame):
-                        out.mux(packet)
-                for packet in stream.encode():
-                    out.mux(packet)
-
-    def test_exact_mid_gop_cut_and_unannotated_schema(self):
-        plan = exporter.load_plan(self.manifest, self.source)
-        output = self.root / "export"
-        report = exporter.convert(plan, self.manifest, output)
-        self.assertEqual((report["episodes"], report["videos"]), (2, 6))
-        task = output / "Order/08-test_sequence"
-        rows = [json.loads(line) for line in (task / "metadata.jsonl").read_text().splitlines()]
-        self.assertEqual([r["total_frames"] for r in rows], [7, 13])
-        for row in rows:
-            self.assertFalse(row["has_annotation"])
-            self.assertIsNone(row["annotation_path"])
-            self.assertIsNone(row["task_prompt"])
-            self.assertEqual(row["source_instruction"], "Press one, then three")
-            self.assertEqual(row["suite"], "Order")
-            for view in row["video_views"].values():
-                path = task / view["video_path"]
-                self.assertEqual(exporter.sha256(path), view["video_sha256"])
-        # Independent pixel check of a non-keyframe-aligned second episode.
-        source = self.source / "recording/videos/observation.images.left_wrist/chunk-000/file-000.mp4"
-        def pixels(path):
-            with av.open(str(path)) as inp:
-                return [hashlib.sha256(f.to_ndarray(format="yuv420p").tobytes()).hexdigest()
-                        for f in inp.decode(video=0)]
-        self.assertEqual(pixels(source)[7:], pixels(task / rows[1]["video_views"]["left_view"]["video_path"]))
-        self.assertEqual(list((task / "annotations").iterdir()), [])
-        additions = json.loads((output / "manifest.additions.json").read_text())
-        split = additions["tasks"][0]
-        self.assertEqual(split["train"], [rows[0]["sample_id"]])
-        self.assertEqual(split["val"], [rows[1]["sample_id"]])
-        self.assertEqual(split["trajectory_index_sha256"], exporter.sha256(task / "metadata.jsonl"))
-        with self.assertRaises(FileExistsError):
-            exporter.convert(plan, self.manifest, output)
-
-    def test_changed_count_and_duplicate_sources_rejected(self):
-        manifest = copy.deepcopy(self.manifest)
-        manifest["tasks"][0]["sources"][0]["episodes"] = 3
-        with self.assertRaisesRegex(ValueError, "count changed"):
-            exporter.load_plan(manifest, self.source)
-        manifest = copy.deepcopy(self.manifest)
-        manifest["tasks"][0]["sources"] *= 2
-        with self.assertRaisesRegex(ValueError, "Duplicate source"):
-            exporter.load_plan(manifest, self.source)
-
-    def test_state_exclusions_keep_source_ids_and_reindex_outputs(self):
-        manifest = copy.deepcopy(self.manifest)
-        manifest.update(suite="State", video_preset="medium")
-        manifest["tasks"][0]["task_id"] = "S11"
-        manifest["tasks"][0]["sources"][0]["exclude_episodes"] = [0]
-        plan = exporter.load_plan(manifest, self.source)
-        self.assertEqual([e["source_episode"] for e in plan[0]["episodes"]], [1])
-        output = self.root / "state"
-        report = exporter.convert(plan, manifest, output)
-        self.assertEqual(report["episodes"], 1)
-        task = output / "State/11-test_sequence"
-        row = json.loads((task / "metadata.jsonl").read_text())
-        self.assertEqual(row["suite"], "State")
-        self.assertEqual(row["episode_index"], 0)
-        self.assertEqual(row["source_sample_id"], "recording/episode_000001")
-        self.assertFalse((output / "Order").exists())
-        split = json.loads((output / "manifest.additions.json").read_text())["tasks"][0]
-        self.assertEqual(split["task_path"], "State/11-test_sequence")
-        self.assertEqual(split["val"], [row["sample_id"]])
-
-    def test_wrong_suite_id_and_invalid_exclusions_rejected(self):
-        manifest = copy.deepcopy(self.manifest)
-        manifest["suite"] = "State"
-        with self.assertRaisesRegex(ValueError, "Invalid State"):
-            exporter.load_plan(manifest, self.source)
-        manifest["tasks"][0]["task_id"] = "S11"
-        for excluded in ([2], [0, 0]):
-            manifest["tasks"][0]["sources"][0]["exclude_episodes"] = excluded
-            with self.assertRaisesRegex(ValueError, "Invalid explicit episode exclusions"):
-                exporter.load_plan(manifest, self.source)
-
-    def test_optional_remux_still_requires_exact_pixels_and_frame_count(self):
-        source = self.source / "recording/videos/observation.images.left_wrist/chunk-000/file-000.mp4"
-        target = self.root / "remux.mp4"
-        details = exporter.export_clip(source, target, 7, 13, 30, remux_first=True)
-        with av.open(str(source)) as inp:
-            expected = [hashlib.sha256(f.to_ndarray(format="yuv420p").tobytes()).hexdigest()
-                        for f in inp.decode(video=0)][7:]
-        with av.open(str(target)) as inp:
-            actual = [hashlib.sha256(f.to_ndarray(format="yuv420p").tobytes()).hexdigest()
-                      for f in inp.decode(video=0)]
-        self.assertEqual(actual, expected)
-        self.assertEqual(details["video_sha256"], exporter.sha256(target))
-
-    def test_truncated_video_does_not_publish_metadata(self):
-        plan = exporter.load_plan(self.manifest, self.source)
-        plan[0]["episodes"][1]["frames"] = 14
-        output = self.root / "bad-export"
-        with self.assertRaisesRegex(ValueError, "Truncated source"):
-            exporter.convert(plan, self.manifest, output)
-        self.assertEqual(json.loads((output / "export-status.json").read_text())["status"], "incomplete")
-        self.assertFalse((output / "Order/08-test_sequence/metadata.jsonl").exists())
-
-    def test_paths_cannot_escape_raw_root(self):
-        with self.assertRaises(ValueError):
-            exporter.child(self.source, "../outside")
-
-    def test_second_shard_uses_its_own_timestamp_origin(self):
-        import shutil
-
-        dataset = self.source / "recording"
-        path = dataset / "meta/episodes/chunk-000/file-000.parquet"
-        rows = pq.read_table(path).to_pylist()
-        for camera in exporter.CAMERAS.values():
-            source = dataset / f"videos/{camera}/chunk-000/file-000.mp4"
-            shutil.copyfile(source, source.with_name("file-001.mp4"))
-            prefix = f"videos/{camera}"
-            rows[1][prefix + "/file_index"] = 1
-            rows[1][prefix + "/from_timestamp"] = 0.0
-            rows[1][prefix + "/to_timestamp"] = 13 / 30
-        pq.write_table(pa.Table.from_pylist(rows), path)
-        plan = exporter.load_plan(self.manifest, self.source)
-        output = self.root / "shard-export"
-        exporter.convert(plan, self.manifest, output)
-        records = json.loads((output / "provenance.json").read_text())["trajectories"]
-        self.assertTrue(all(r["source_start_frame"] == 0 for r in records[3:]))
-
-
-if __name__ == "__main__":
-    unittest.main()

provenance/evomind-state-20261102/tests.log

@@ -1,19 +0,0 @@
-test_changed_count_and_duplicate_sources_rejected (test_export_order.ExportTests.test_changed_count_and_duplicate_sources_rejected) ... ok
-test_exact_mid_gop_cut_and_unannotated_schema (test_export_order.ExportTests.test_exact_mid_gop_cut_and_unannotated_schema) ... O08 episode 1/2 verified
-O08 episode 2/2 verified
-ok
-test_optional_remux_still_requires_exact_pixels_and_frame_count (test_export_order.ExportTests.test_optional_remux_still_requires_exact_pixels_and_frame_count) ... ok
-test_paths_cannot_escape_raw_root (test_export_order.ExportTests.test_paths_cannot_escape_raw_root) ... ok
-test_second_shard_uses_its_own_timestamp_origin (test_export_order.ExportTests.test_second_shard_uses_its_own_timestamp_origin) ... O08 episode 1/2 verified
-O08 episode 2/2 verified
-ok
-test_state_exclusions_keep_source_ids_and_reindex_outputs (test_export_order.ExportTests.test_state_exclusions_keep_source_ids_and_reindex_outputs) ... S11 episode 1/1 verified
-ok
-test_truncated_video_does_not_publish_metadata (test_export_order.ExportTests.test_truncated_video_does_not_publish_metadata) ... O08 episode 1/2 verified
-ok
-test_wrong_suite_id_and_invalid_exclusions_rejected (test_export_order.ExportTests.test_wrong_suite_id_and_invalid_exclusions_rejected) ... ok
-
-----------------------------------------------------------------------
-Ran 8 tests in 0.259s
-
-OK

provenance/evomind-state-20261102/validation.json

@@ -1,44 +0,0 @@
-{
-  "status": "passed",
-  "partial": false,
-  "tasks": [
-    {
-      "task_id": "S11",
-      "directory": "State/11-put_three_coins_into_piggy_bank",
-      "episodes": 32,
-      "frames": 28951,
-      "warnings": []
-    },
-    {
-      "task_id": "S12",
-      "directory": "State/12-inspect_four_objects_and_return",
-      "episodes": 35,
-      "frames": 31753,
-      "warnings": []
-    },
-    {
-      "task_id": "S13",
-      "directory": "State/13-inspect_three_drawers",
-      "episodes": 35,
-      "frames": 34646,
-      "warnings": []
-    },
-    {
-      "task_id": "S14",
-      "directory": "State/14-weigh_four_objects_and_return",
-      "episodes": 35,
-      "frames": 50435,
-      "warnings": []
-    },
-    {
-      "task_id": "S15",
-      "directory": "State/15-inspect_three_test_tubes",
-      "episodes": 49,
-      "frames": 43629,
-      "warnings": []
-    }
-  ],
-  "episodes": 186,
-  "videos": 558,
-  "checks": "Full output decode; frame counts, timestamps and decoded YUV equality to source cuts; source metadata hashes."
-}