motionloom 2.6.1 → 2.7.0

package/scripts/browser_review_consistency.py

@@ -0,0 +1,64 @@
+"""Shared browser-review candidate consistency checks."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+# These fields determine which exact candidate was reviewed. The URL is
+# intentionally excluded because a Dev Lab deployment may legitimately use a
+# different host/base path while the candidate bytes remain identical.
+IDENTITY_FIELDS = (
+    "candidate_id",
+    "task_id",
+    "scene",
+    "source_sha256",
+    "context_sha256",
+    "status",
+    "expires_at",
+    "runtime_review",
+)
+
+
+def read_json(path: Path) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def candidate_consistency_errors(
+    scene_candidate_path: Path,
+    task_candidate_path: Path,
+    *,
+    expected_task_id: str | None = None,
+    expected_scene: str | None = None,
+) -> list[str]:
+    """Return fail-closed errors for scene/task browser-review divergence."""
+
+    errors: list[str] = []
+    if not scene_candidate_path.is_file():
+        return ["scene-level browser-review.json is required when a task bundle is used"]
+    if not task_candidate_path.is_file():
+        return ["task-level browser-review.json is required when a task bundle is used"]
+
+    scene_candidate = read_json(scene_candidate_path)
+    task_candidate = read_json(task_candidate_path)
+    if not scene_candidate:
+        errors.append("scene-level browser-review.json is invalid or empty")
+    if not task_candidate:
+        errors.append("task-level browser-review.json is invalid or empty")
+
+    for field in IDENTITY_FIELDS:
+        if scene_candidate.get(field) != task_candidate.get(field):
+            errors.append(f"scene/task browser-review {field} mismatch")
+
+    if expected_task_id is not None and task_candidate.get("task_id") != expected_task_id:
+        errors.append("task-level browser-review task_id does not match task.json")
+    if expected_scene is not None and task_candidate.get("scene") != expected_scene:
+        errors.append("task-level browser-review scene does not match scene directory")
+
+    return errors

package/scripts/fetch-project-corpus.py

@@ -0,0 +1,91 @@
+"""Fetch the explicitly requested external analyzer corpus without installing or executing it."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_MANIFEST = ROOT / "tests/evals/project-corpus.json"
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def run(command: list[str], cwd: Path | None = None) -> str:
+    result = subprocess.run(command, cwd=cwd, capture_output=True, text=True)
+    if result.returncode != 0:
+        detail = (result.stderr or result.stdout).strip()
+        raise RuntimeError(f"{' '.join(command)} failed: {detail}")
+    return result.stdout.strip()
+
+
+def safe_destination(workspace: Path, relative: str) -> Path:
+    destination = (workspace / relative).resolve()
+    if workspace.resolve() not in destination.parents:
+        raise ValueError(f"manifest local_path escapes workspace: {relative}")
+    return destination
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--manifest", default=str(DEFAULT_MANIFEST))
+    parser.add_argument("--workspace", required=True, help="Directory that will contain external checkouts")
+    parser.add_argument("--project", action="append", default=[], help="Manifest project id; repeatable")
+    parser.add_argument("--all", action="store_true", help="Fetch every external project in the manifest")
+    parser.add_argument("--depth", type=int, default=1)
+    parser.add_argument("--refresh", action="store_true", help="Remove and re-fetch existing selected checkouts")
+    args = parser.parse_args()
+    if not args.all and not args.project:
+        parser.error("choose --all or at least one --project")
+    if args.depth < 1:
+        parser.error("--depth must be positive")
+
+    manifest_path = Path(args.manifest).expanduser().resolve()
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    cases = [case for case in manifest.get("projects", []) if case.get("external") is True]
+    selected = set(case["id"] for case in cases) if args.all else set(args.project)
+    known = {case["id"] for case in cases}
+    unknown = sorted(selected - known)
+    if unknown:
+        raise ValueError(f"unknown external project id(s): {', '.join(unknown)}")
+
+    workspace = Path(args.workspace).expanduser().resolve()
+    workspace.mkdir(parents=True, exist_ok=True)
+    fetched: list[dict[str, str]] = []
+    for case in cases:
+        if case["id"] not in selected:
+            continue
+        destination = safe_destination(workspace, str(case["local_path"]))
+        if destination.exists() or destination.is_symlink():
+            if not args.refresh:
+                raise RuntimeError(f"checkout already exists: {destination}; pass --refresh to replace it")
+            if destination.is_symlink() or not destination.is_dir():
+                raise RuntimeError(f"refusing to remove non-directory checkout path: {destination}")
+            shutil.rmtree(destination)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        source = str(case["source"])
+        run(["git", "clone", "--depth", str(args.depth), source, str(destination)])
+        commit = run(["git", "rev-parse", "HEAD"], cwd=destination)
+        fetched.append({"id": case["id"], "source": source, "path": str(destination), "commit": commit})
+
+    record = {
+        "schema_version": "1.0",
+        "manifest": str(manifest_path),
+        "fetched_at": now(),
+        "policy": "clone-only; no install, build, test or external code execution",
+        "projects": fetched,
+    }
+    record_path = workspace / ".motionloom-corpus-fetch.json"
+    record_path.write_text(json.dumps(record, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    print(json.dumps({"status": "pass", "workspace": str(workspace), "projects": fetched, "record": str(record_path)}, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/frame-generation-lock.py

@@ -65,8 +65,30 @@ def validate(document: dict[str, Any], root: Path) -> dict[str, Any]:
         if key not in document:
             errors.append(issue("missing_field", f"required field is missing: {key}", key))
 
-    if document.get("schema_version") != "0.1":
-        errors.append(issue("schema_version", "frame generation lock schema_version must be 0.1", "schema_version"))
+    if document.get("schema_version") not in {"0.1", "0.2"}:
+        errors.append(issue("schema_version", "frame generation lock schema_version must be 0.1 or 0.2", "schema_version"))
+    enhanced = document.get("schema_version") == "0.2"
+    if enhanced:
+        if not ID_RE.match(str(document.get("sequence_id", ""))):
+            errors.append(issue("invalid_sequence_id", "schema_version 0.2 requires a safe sequence_id", "sequence_id"))
+        forbidden = document.get("forbidden_action_ids")
+        if not isinstance(forbidden, list) or not forbidden or any(not FRAME_RE.match(str(item)) for item in forbidden):
+            errors.append(issue("invalid_forbidden_actions", "schema_version 0.2 requires a non-empty safe forbidden_action_ids array", "forbidden_action_ids"))
+        elif str(document.get("action_id")) in {str(item) for item in forbidden}:
+            errors.append(issue("expected_action_forbidden", "action_id must not also be forbidden", "forbidden_action_ids"))
+        contract = document.get("action_contract") if isinstance(document.get("action_contract"), dict) else {}
+        action_manifest = str(document.get("action_manifest", ""))
+        if not action_manifest.lower().endswith(".json"):
+            errors.append(issue("invalid_action_manifest", "schema_version 0.2 requires a JSON action_manifest path", "action_manifest"))
+        else:
+            _, manifest_error = inside(root, action_manifest)
+            if manifest_error:
+                manifest_error["path"] = "action_manifest"
+                errors.append(manifest_error)
+        for key in ("positive_cues", "negative_cues"):
+            values = contract.get(key)
+            if not isinstance(values, list) or not values or any(not isinstance(item, str) or not item.strip() for item in values):
+                errors.append(issue("invalid_action_contract", f"action_contract.{key} must be a non-empty string array", f"action_contract.{key}"))
     if not ID_RE.match(str(document.get("lock_id", ""))):
         errors.append(issue("invalid_lock_id", "lock_id must use lowercase safe identifier characters", "lock_id"))
     if not FRAME_RE.match(str(document.get("action_id", ""))):
@@ -228,8 +250,13 @@ def compose_instruction(document: dict[str, Any], frame: dict[str, Any]) -> str:
     preserve = "; ".join(str(value).strip() for value in appearance["preserve"])
     forbid = "; ".join(str(value).strip() for value in appearance["forbid"])
     pixel_rule = " Use crisp nearest-neighbor pixel edges; do not resample or blur." if appearance.get("pixel_art", {}).get("enabled") else ""
+    sequence_clause = f" Sequence {document['sequence_id']} is immutable across this action." if document.get("sequence_id") else ""
+    contract = document.get("action_contract") if isinstance(document.get("action_contract"), dict) else {}
+    positive_clause = "; ".join(str(item).strip() for item in contract.get("positive_cues", []))
+    negative_clause = "; ".join(str(item).strip() for item in contract.get("negative_cues", []))
+    action_clause = f" Positive action cues: {positive_clause}. Negative action cues: {negative_clause}. Forbidden competing actions: {', '.join(str(item) for item in document.get('forbidden_action_ids', []))}." if positive_clause and negative_clause else ""
     return (
-        f"MotionLoom Frame Generation Lock {document['lock_id']} for action {document['action_id']}. "
+        f"MotionLoom Frame Generation Lock {document['lock_id']} for action {document['action_id']}.{sequence_clause} "
         f"Use reference image {reference['image']} as the locked {reference['role']} with SHA-256 {reference['sha256']}. "
         f"Generate exactly ONE isolated source frame for {frame['frame_id']}; never create a pose sheet, contact sheet, collage, atlas, or multiple poses in one image. "
         f"Pose: {frame['pose']} "
@@ -238,7 +265,7 @@ def compose_instruction(document: dict[str, Any], frame: dict[str, Any]) -> str:
         f"Keep all opaque pixels inside safe rect x={safe['x']}, y={safe['y']}, width={safe['width']}, height={safe['height']} and preserve at least {geometry['min_padding_px']} px transparent padding. "
         f"Target apparent alpha bounds are approximately {target['width']} × {target['height']} px; do not introduce whole-subject zoom drift beyond ±{tolerances['bbox_width_px']} px width or ±{tolerances['bbox_height_px']} px height, pivot drift beyond ±{tolerances['pivot_px']} px, or footline drift beyond ±{tolerances['footline_px']} px. "
         f"Preserve: {preserve}. Forbid: {forbid}.{pixel_rule} "
-        f"Do not mirror, crop from a shared canvas, silently change camera/scale, or resize the generated frame afterward. "
+        f"Do not mirror, crop from a shared canvas, silently change camera/scale, or resize the generated frame afterward.{action_clause} "
         f"Return/save only the single PNG as {frame['output']}. This is review evidence only; generation success does not imply artist authorship, production eligibility, runtime approval, licence, or user approval."
     )
 
@@ -267,15 +294,18 @@ def compose(document: dict[str, Any], root: Path, frame_id: str | None = None) -
         for frame in frames
         if isinstance(frame, dict)
     ]
+    manifest_flag = f" --action-manifest {document['action_manifest']}" if document.get("action_manifest") else ""
     return {
         "contract": "frame_generation_lock",
         "ready": True,
         "lock_id": document["lock_id"],
         "action_id": document["action_id"],
+        "sequence_id": document.get("sequence_id"),
+        "forbidden_action_ids": document.get("forbidden_action_ids", []),
         "lock_sha256": validation["metrics"]["lock_sha256"],
         "reference_sha256": validation["metrics"]["reference_sha256"],
         "frames": items,
-        "next_gate": f"motionloom frame-set-preflight --input {postflight} --root {root} --json",
+        "next_gate": f"motionloom frame-set-preflight --input {postflight} --root {root}{manifest_flag} --json",
         "approval": False,
     }
 

package/scripts/frame-set-preflight.py

@@ -21,6 +21,17 @@ from typing import Any
 
 ROOT = Path(__file__).resolve().parents[1]
 ASSET_CONSISTENCY = ROOT / "scripts" / "asset-consistency.py"
+ACTION_SEPARATION = ROOT / "scripts" / "action-separation.py"
+
+
+def load_action_separation():
+    spec = importlib.util.spec_from_file_location("motionloom_action_separation", ACTION_SEPARATION)
+    if spec is None or spec.loader is None:
+        raise RuntimeError("cannot load action-separation.py")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
 
 
 def load_asset_consistency():
@@ -34,6 +45,7 @@ def load_asset_consistency():
 
 
 AC = load_asset_consistency()
+AS = load_action_separation()
 
 
 def _error(code: str, message: str, path: str = "") -> dict[str, str]:
@@ -66,7 +78,12 @@ def _shrink(rect: dict[str, int], margin: int) -> dict[str, int] | None:
     }
 
 
-def validate(document: dict[str, Any], root: Path, allow_shared_source: bool = False) -> dict[str, Any]:
+def validate(
+    document: dict[str, Any],
+    root: Path,
+    allow_shared_source: bool = False,
+    action_manifest: dict[str, Any] | None = None,
+) -> dict[str, Any]:
     base = AC.validate_frame_geometry(document, root)
     errors = list(base.get("errors", []))
     warnings = list(base.get("warnings", []))
@@ -143,6 +160,12 @@ def validate(document: dict[str, Any], root: Path, allow_shared_source: bool = F
                     )
                 )
 
+    action_result = None
+    if action_manifest is not None:
+        action_result = AS.validate_manifest(action_manifest, root)
+        errors.extend(action_result.get("errors", []))
+        warnings.extend(action_result.get("warnings", []))
+
     remaining_warnings: list[dict[str, Any]] = []
     for item in warnings:
         if isinstance(item, dict) and item.get("code") == "bbox_drift":
@@ -162,6 +185,7 @@ def validate(document: dict[str, Any], root: Path, allow_shared_source: bool = F
             **base.get("metrics", {}),
             "isolated_source_required": not allow_shared_source,
             "unique_source_images": len(seen_images),
+            "action_manifest": action_result.get("metrics") if action_result else None,
         },
         "approval": False,
     }
@@ -172,6 +196,7 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--input", required=True, help="frame-geometry contract JSON")
     parser.add_argument("--root", default=".", help="root used to resolve frame paths")
     parser.add_argument("--allow-shared-source", action="store_true", help="for imported/shared canvases only; not recommended for generated source frames")
+    parser.add_argument("--action-manifest", help="action-sequence manifest; validates frame envelopes and action separation")
     parser.add_argument("--json", action="store_true", dest="as_json")
     args = parser.parse_args(argv)
 
@@ -197,7 +222,32 @@ def main(argv: list[str] | None = None) -> int:
                 "approval": False,
             }
         else:
-            result = validate(document, Path(args.root).resolve(), args.allow_shared_source)
+            action_manifest = None
+            if args.action_manifest:
+                try:
+                    action_manifest = json.loads(Path(args.action_manifest).read_text(encoding="utf-8"))
+                except (OSError, json.JSONDecodeError) as exc:
+                    result = {
+                        "contract": "generated_frame_set_preflight",
+                        "ready": False,
+                        "errors": [_error("invalid_action_manifest", str(exc), args.action_manifest)],
+                        "warnings": [],
+                        "metrics": {},
+                        "approval": False,
+                    }
+                    action_manifest = None
+                if action_manifest is not None and not isinstance(action_manifest, dict):
+                    result = {
+                        "contract": "generated_frame_set_preflight",
+                        "ready": False,
+                        "errors": [_error("invalid_action_manifest", "action manifest root must be an object", args.action_manifest)],
+                        "warnings": [],
+                        "metrics": {},
+                        "approval": False,
+                    }
+                    action_manifest = None
+            if action_manifest is not None or not args.action_manifest:
+                result = validate(document, Path(args.root).resolve(), args.allow_shared_source, action_manifest)
 
     if args.as_json:
         print(json.dumps(result, indent=2, ensure_ascii=False))

package/scripts/package-consumer-smoke.mjs

@@ -69,6 +69,26 @@ try {
   if (!fs.existsSync(path.join(installedRoot, "dev-lab", "public", "scenes", scene, "browser-review.json"))) {
     throw new Error("installed Dev Lab did not prepare the consumer scene");
   }
+  const requestSource = path.join(installedRoot, "examples", "agent-consumer", "asset-planning", "pixellab-hero-256x448-request.json");
+  const requestCopy = path.join(consumer, "asset-generation-request.json");
+  const registryCopy = path.join(consumer, "artifact-adapter-registry.json");
+  fs.copyFileSync(requestSource, requestCopy);
+  fs.copyFileSync(path.join(installedRoot, "artifact-adapter-registry.json"), registryCopy);
+  const plan = JSON.parse(run(bin, ["asset-generation-plan", "plan", "--request", requestCopy, "--registry", registryCopy, "--project-root", consumer.toString(), "--json"], { cwd: consumer }));
+  if (plan.contract !== "motionloom-asset-generation-plan" || plan.schema_version !== "0.2" || plan.producer !== "MotionLoom" || plan.approval !== false) throw new Error("installed planner contract failed");
+  if (!Array.isArray(plan.recommendations) || plan.recommendations.length === 0) throw new Error("installed planner returned no normal-planning recommendations");
+  if (!plan.recommendations.some((item) => item.recommendation_status === "recommended" && item.execution_status === "provisional")) throw new Error("installed planner lost provisional recommendation/execution separation");
+  if (!plan.agent_guidance || plan.agent_guidance.recommended_by !== "MotionLoom") throw new Error("installed planner omitted MotionLoom agent guidance");
+  const humanPlan = run(bin, ["asset-generation-plan", "plan", "--request", requestCopy, "--registry", registryCopy, "--project-root", consumer.toString()], { cwd: consumer });
+  if (!humanPlan.includes("MotionLoom Project Assessment") || !humanPlan.includes("MotionLoom Recommendations")) throw new Error("installed planner human output lost MotionLoom identity");
+
+  const sourceImage = path.join(installedRoot, "examples", "agent-consumer", "asset-consistency", "assets", "hero-frame-00.png");
+  const adaptedImage = path.join(consumer, "adapted-frame.png");
+  const adaptationReport = path.join(consumer, "adaptation-report.json");
+  const adaptation = JSON.parse(run(bin, ["asset-adapt", "pad", "--input", sourceImage, "--output", adaptedImage, "--width", "256", "--height", "448", "--anchor", "footline", "--report", adaptationReport, "--json"], { cwd: consumer }));
+  if (adaptation.contract !== "motionloom-asset-adaptation" || adaptation.approval !== false || adaptation.output.canvas[0] !== 256 || adaptation.output.canvas[1] !== 448) throw new Error("installed Node asset-adapt contract failed");
+  if (!fs.existsSync(adaptedImage) || !fs.existsSync(adaptationReport)) throw new Error("installed asset-adapt omitted output/report");
+
   run(process.execPath, ["--input-type=module", "-e", "await import('playwright'); await import('vite');"], { cwd: consumer });
   console.log(JSON.stringify({ status: "pass", project_root: init.project_root, installed_root: installedRoot }, null, 2));
 } finally {

package/scripts/quality-gate.py

@@ -19,6 +19,7 @@ ROOT = Path(__file__).resolve().parents[1]
 SAFE_SCENE = re.compile(r"^[A-Za-z0-9._-]+$")
 sys.path.insert(0, str(ROOT / "scripts"))
 from intelligence import validate_task_benchmark, validate_task_intelligence, validate_task_p1  # noqa: E402
+from browser_review_consistency import candidate_consistency_errors  # noqa: E402
 sys.path.insert(0, str(ROOT / "src"))
 from core.spec import validate_spec  # noqa: E402
 
@@ -321,6 +322,12 @@ def validate_scene(scene_dir: Path, context_path: Path, require_review: bool = F
                     issues.append("browser review candidate scene mismatch")
                 if task_dir:
                     task = _json(task_dir / "task.json")
+                    issues.extend(candidate_consistency_errors(
+                        scene_dir / "browser-review.json",
+                        task_dir / "browser-review.json",
+                        expected_task_id=task.get("task_id"),
+                        expected_scene=scene_dir.name,
+                    ))
                     if candidate.get("task_id") != task.get("task_id"):
                         issues.append("browser review candidate task_id mismatch")
                 if candidate.get("source_sha256") != source_sha:

package/scripts/release-verify.py

@@ -20,6 +20,7 @@ def main() -> int:
     parser.add_argument("--changelog", default=str(ROOT / "CHANGELOG.md"))
     parser.add_argument("--release-note", default="")
     parser.add_argument("--tag", default="", help="Optional Git tag; accepts v<version> or <version>")
+    parser.add_argument("--capability-registry", default=str(ROOT / "capability-registry.json"))
     args = parser.parse_args()
 
     errors: list[str] = []
@@ -43,6 +44,30 @@ def main() -> int:
     if args.tag and args.tag.removeprefix("v") != expected:
         errors.append(f"tag {args.tag!r} does not match version {expected!r}")
 
+    registry_path = Path(args.capability_registry).resolve()
+    try:
+        registry = json.loads(registry_path.read_text(encoding="utf-8"))
+        expected_registry_id = f"registry-{package.get('name', 'motionloom')}-{expected}"
+        if registry.get("registry_id") != expected_registry_id:
+            errors.append(
+                f"capability registry id {registry.get('registry_id')!r} does not match {expected_registry_id!r}"
+            )
+        capabilities = registry.get("capabilities")
+        if not isinstance(capabilities, list) or not capabilities:
+            errors.append("capability registry must contain a non-empty capabilities array")
+        else:
+            mismatched = [
+                str(item.get("id", "<unknown>"))
+                for item in capabilities
+                if item.get("adapter_version") != expected
+            ]
+            if mismatched:
+                errors.append(
+                    "capability registry adapter_version mismatch: " + ", ".join(mismatched)
+                )
+    except (OSError, json.JSONDecodeError, AttributeError) as exc:
+        errors.append(f"capability registry is invalid: {exc}")
+
     report = {"status": "fail" if errors else "pass", "version": actual, "expected_version": expected, "errors": errors}
     print(json.dumps(report, indent=2))
     return 1 if errors else 0

package/scripts/report-contract.py

@@ -91,7 +91,7 @@ def main() -> int:
         passing: list[Path] = []
         for task_dir in complete:
             result = subprocess.run(
-                [sys.executable, str(report_script), "check", "--task-dir", str(task_dir)],
+                [sys.executable, str(report_script), "check", "--task-dir", str(task_dir), "--root", str(root)],
                 cwd=root,
                 capture_output=True,
                 text=True,

package/scripts/report.py

@@ -12,8 +12,11 @@ import sys
 from datetime import datetime, timezone
 from pathlib import Path
 
+from browser_review_consistency import candidate_consistency_errors
 
-ROOT = Path(__file__).resolve().parents[1]
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[1]
+ROOT = PACKAGE_ROOT
 EVIDENCE_ARTIFACTS = (
     "semantic-lint-benchmark.json",
     "evidence-verifier-report.json",
@@ -56,7 +59,7 @@ def project_memory_path() -> Path:
 
 
 def asset_provenance_module():
-    path = ROOT / "scripts" / "asset-provenance.py"
+    path = PACKAGE_ROOT / "scripts" / "asset-provenance.py"
     loader = importlib.util.spec_from_file_location("motionloom_asset_provenance", path)
     module = importlib.util.module_from_spec(loader)
     loader.loader.exec_module(module)
@@ -64,7 +67,7 @@ def asset_provenance_module():
 
 
 def asset_consistency_module():
-    path = ROOT / "scripts" / "asset-consistency.py"
+    path = PACKAGE_ROOT / "scripts" / "asset-consistency.py"
     loader = importlib.util.spec_from_file_location("motionloom_asset_consistency", path)
     module = importlib.util.module_from_spec(loader)
     sys.modules[loader.name] = module
@@ -73,7 +76,7 @@ def asset_consistency_module():
 
 
 def artifact_intake_module():
-    path = ROOT / "scripts" / "artifact-intake.py"
+    path = PACKAGE_ROOT / "scripts" / "artifact-intake.py"
     loader = importlib.util.spec_from_file_location("motionloom_artifact_intake", path)
     module = importlib.util.module_from_spec(loader)
     sys.modules[loader.name] = module
@@ -450,6 +453,14 @@ def approval_contract_errors(task_dir: Path, task: dict, require_current: bool)
         return ["ready-for-PR task requires review.json"]
     if candidate.get("task_id") != task.get("task_id"):
         errors.append("browser-review candidate task_id does not match task.json")
+    scene_candidate_path = ROOT / "src" / "output" / str(task.get("scene", "")) / "browser-review.json"
+    if scene_candidate_path.is_file():
+        errors.extend(candidate_consistency_errors(
+            scene_candidate_path,
+            candidate_path,
+            expected_task_id=task.get("task_id"),
+            expected_scene=task.get("scene"),
+        ))
     if candidate.get("scene") != task.get("scene"):
         errors.append("browser-review candidate scene does not match task.json")
     task_review = task.get("browser_review") or {}
@@ -717,6 +728,7 @@ def render(args: argparse.Namespace) -> int:
 
 
 def main() -> int:
+    global ROOT
     parser = argparse.ArgumentParser(description=__doc__)
     sub = parser.add_subparsers(dest="command", required=True)
     init = sub.add_parser("init")
@@ -772,8 +784,11 @@ def main() -> int:
     structure_parser.set_defaults(func=record_structure)
     check_parser = sub.add_parser("check", help="Validate semantic completeness of a task bundle")
     check_parser.add_argument("--task-dir", required=True)
+    check_parser.add_argument("--root", default=str(ROOT), help="Repository root containing the canonical scene artifacts")
     check_parser.set_defaults(func=check_report)
     args = parser.parse_args()
+    if hasattr(args, "root"):
+        ROOT = Path(args.root).expanduser().resolve()
     return args.func(args)
 
 

package/scripts/resolve-task-bundle.py

@@ -4,7 +4,7 @@
 The resolver intentionally does not infer a task path from a scene slug. A
 bundle is eligible only when its direct ``artifacts/<task-id>/task.json``
 declares the requested scene and remains inside the repository artifacts root.
-Multiple matching bundles are rejected rather than ranked implicitly.
+Multiple matching bundles are rejected rather than ranked implicitly. A task bundle with a browser-review candidate that conflicts with the canonical scene candidate is not eligible; the later quality/review gates still report that divergence when the bundle is checked directly.
 """
 
 from __future__ import annotations
@@ -44,6 +44,7 @@ def resolve_task_dirs(root: Path, scene: str) -> list[Path]:
     if not artifacts.is_dir() or artifacts.is_symlink():
         return []
     resolved_artifacts = artifacts.resolve()
+    scene_candidate = read_json(root / "src" / "output" / scene / "browser-review.json")
     matches: list[Path] = []
     for task_path in sorted(artifacts.glob("*/task.json")):
         if has_symlink_component(task_path, root):
@@ -53,8 +54,15 @@ def resolve_task_dirs(root: Path, scene: str) -> list[Path]:
                 continue
         except (OSError, RuntimeError):
             continue
-        if read_json(task_path).get("scene") == scene:
-            matches.append(task_path.parent)
+        task = read_json(task_path)
+        if task.get("scene") != scene:
+            continue
+        task_candidate = read_json(task_path.parent / "browser-review.json")
+        if scene_candidate and task_candidate:
+            identity_fields = ("candidate_id", "task_id", "scene", "source_sha256", "context_sha256", "expires_at")
+            if any(scene_candidate.get(field) != task_candidate.get(field) for field in identity_fields):
+                continue
+        matches.append(task_path.parent)
     return matches