@hybridlabor-api/aos 4.6.6 → 4.7.1

package/skills/global_config/editable-design/scripts/remove-chroma-key.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""Turn a flat chroma-key image into a PNG or WebP with alpha."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import re
+from statistics import median
+import sys
+
+
+def fail(message: str) -> None:
+    print(f"remove-chroma-key: {message}", file=sys.stderr)
+    raise SystemExit(2)
+
+
+def load_pillow():
+    try:
+        from PIL import Image, ImageFilter
+    except ImportError:
+        fail("Pillow is required; install it with `python3 -m pip install pillow`.")
+    return Image, ImageFilter
+
+
+def parse_color(value: str) -> tuple[int, int, int]:
+    match = re.fullmatch(r"#?([0-9a-fA-F]{6})", value.strip())
+    if not match:
+        fail("--key-color must be a six-digit RGB hex value such as #00ff00")
+    raw = match.group(1)
+    return tuple(int(raw[index : index + 2], 16) for index in (0, 2, 4))
+
+
+def sample_key(image, mode: str) -> tuple[int, int, int]:
+    width, height = image.size
+    pixels = image.load()
+    samples: list[tuple[int, int, int]] = []
+    band = max(1, min(width, height, 6))
+
+    if mode == "corners":
+        patch = max(1, min(width, height, 12))
+        boxes = (
+            (0, 0, patch, patch),
+            (width - patch, 0, width, patch),
+            (0, height - patch, patch, height),
+            (width - patch, height - patch, width, height),
+        )
+        for left, top, right, bottom in boxes:
+            for y in range(top, bottom):
+                for x in range(left, right):
+                    samples.append(tuple(pixels[x, y][:3]))
+    else:
+        step = max(1, min(width, height) // 256)
+        for x in range(0, width, step):
+            for offset in range(band):
+                samples.append(tuple(pixels[x, offset][:3]))
+                samples.append(tuple(pixels[x, height - 1 - offset][:3]))
+        for y in range(0, height, step):
+            for offset in range(band):
+                samples.append(tuple(pixels[offset, y][:3]))
+                samples.append(tuple(pixels[width - 1 - offset, y][:3]))
+
+    if not samples:
+        fail("could not sample a key color from the image border")
+    return tuple(int(round(median(pixel[channel] for pixel in samples))) for channel in range(3))
+
+
+def smoothstep(value: float) -> float:
+    value = max(0.0, min(1.0, value))
+    return value * value * (3.0 - 2.0 * value)
+
+
+def matte_alpha(distance: int, transparent: float, opaque: float) -> int:
+    if distance <= transparent:
+        return 0
+    if distance >= opaque:
+        return 255
+    return round(255 * smoothstep((distance - transparent) / (opaque - transparent)))
+
+
+def spill_channels(key: tuple[int, int, int]) -> list[int]:
+    maximum = max(key)
+    if maximum < 128:
+        return []
+    return [index for index, value in enumerate(key) if value >= maximum - 16 and value >= 128]
+
+
+def dominance(rgb: tuple[int, int, int], key: tuple[int, int, int]) -> float:
+    spills = spill_channels(key)
+    if not spills:
+        return 0.0
+    others = [index for index in range(3) if index not in spills]
+    key_strength = min(rgb[index] for index in spills)
+    other_strength = max((rgb[index] for index in others), default=0)
+    return float(key_strength - other_strength)
+
+
+def dominance_alpha(rgb: tuple[int, int, int], key: tuple[int, int, int]) -> int:
+    amount = dominance(rgb, key)
+    if amount <= 0:
+        return 255
+    spills = spill_channels(key)
+    others = [index for index in range(3) if index not in spills]
+    other_strength = max((rgb[index] for index in others), default=0)
+    denominator = max(1.0, max(key) - other_strength)
+    return round(255 * (1.0 - min(1.0, amount / denominator)))
+
+
+def despill(rgb: tuple[int, int, int], key: tuple[int, int, int], alpha: int) -> tuple[int, int, int]:
+    if alpha >= 252:
+        return rgb
+    spills = spill_channels(key)
+    others = [index for index in range(3) if index not in spills]
+    if not spills or not others:
+        return rgb
+    values = list(rgb)
+    cap = max(0, max(values[index] for index in others) - 1)
+    for index in spills:
+        values[index] = min(values[index], cap)
+    return tuple(values)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input", required=True)
+    parser.add_argument("--out", required=True)
+    parser.add_argument("--key-color", default="#00ff00")
+    parser.add_argument("--auto-key", choices=("none", "corners", "border"), default="border")
+    parser.add_argument("--soft-matte", action="store_true")
+    parser.add_argument("--transparent-threshold", type=float, default=12.0)
+    parser.add_argument("--opaque-threshold", type=float, default=220.0)
+    parser.add_argument("--despill", action="store_true")
+    parser.add_argument("--edge-contract", type=int, default=0)
+    parser.add_argument("--edge-feather", type=float, default=0.0)
+    parser.add_argument("--force", action="store_true")
+    return parser
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    source = Path(args.input)
+    output = Path(args.out)
+    if not source.is_file():
+        fail(f"input image not found: {source}")
+    if output.exists() and not args.force:
+        fail(f"output already exists: {output}; pass --force to replace it")
+    if output.suffix.lower() not in {".png", ".webp"}:
+        fail("--out must end in .png or .webp")
+    if not 0 <= args.transparent_threshold < args.opaque_threshold <= 255:
+        fail("matte thresholds must satisfy 0 <= transparent < opaque <= 255")
+    if not 0 <= args.edge_contract <= 16 or not 0 <= args.edge_feather <= 64:
+        fail("edge contract must be 0..16 and edge feather must be 0..64")
+
+    Image, ImageFilter = load_pillow()
+    with Image.open(source) as opened:
+        image = opened.convert("RGBA")
+    key = sample_key(image, args.auto_key) if args.auto_key != "none" else parse_color(args.key_color)
+    pixels = image.load()
+    width, height = image.size
+
+    for y in range(height):
+        for x in range(width):
+            red, green, blue, original_alpha = pixels[x, y]
+            rgb = (red, green, blue)
+            distance = max(abs(rgb[index] - key[index]) for index in range(3))
+            key_like = distance <= 32 or dominance(rgb, key) >= 16
+            alpha = 255
+            if key_like:
+                alpha = min(
+                    matte_alpha(distance, args.transparent_threshold, args.opaque_threshold),
+                    dominance_alpha(rgb, key),
+                )
+            alpha = round(alpha * original_alpha / 255)
+            if alpha <= 8:
+                pixels[x, y] = (0, 0, 0, 0)
+                continue
+            if args.despill and key_like:
+                red, green, blue = despill(rgb, key, alpha)
+            pixels[x, y] = (red, green, blue, alpha)
+
+    alpha_channel = image.getchannel("A")
+    for _ in range(args.edge_contract):
+        alpha_channel = alpha_channel.filter(ImageFilter.MinFilter(3))
+    if args.edge_feather:
+        alpha_channel = alpha_channel.filter(ImageFilter.GaussianBlur(args.edge_feather))
+    image.putalpha(alpha_channel)
+
+    histogram = alpha_channel.histogram()
+    total = width * height
+    transparent = sum(histogram[:13])
+    partial = sum(histogram[13:255])
+    output.parent.mkdir(parents=True, exist_ok=True)
+    image.save(output)
+    print(f"wrote {output}")
+    print(f"key color: #{key[0]:02x}{key[1]:02x}{key[2]:02x}")
+    print(f"transparent pixels: {transparent}/{total}")
+    print(f"partially transparent pixels: {partial}/{total}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/global_config/editable-design/scripts/render-poster.sh

@@ -0,0 +1,202 @@
+#!/usr/bin/env bash
+# Render the poster with the host browser, then read the real pixel dimensions
+# back and compare them with the declared canvas.
+#
+# The read-back is not redundant: a browser silently produces a different size
+# when the window and the content disagree, and the resulting image looks
+# perfectly normal. Trust the artefact, not the renderer's exit code.
+set -euo pipefail
+
+find_browser() {
+  local candidates=(
+    "${EDITABLE_DESIGN_BROWSER:-}"
+    "${PUPPETEER_EXECUTABLE_PATH:-}"
+    "${POSTER_BROWSER:-}"
+    "${CHROME_PATH:-}"
+  )
+  local candidate
+  for candidate in "${candidates[@]}"; do
+    [[ -n "$candidate" && -x "$candidate" ]] && { printf '%s' "$candidate"; return 0; }
+  done
+  for candidate in chromium google-chrome chrome; do
+    local found
+    found="$(command -v "$candidate" 2>/dev/null || true)"
+    [[ -n "$found" ]] && { printf '%s' "$found"; return 0; }
+  done
+  candidates=(
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+    "/Applications/Chromium.app/Contents/MacOS/Chromium"
+    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+    "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+  )
+  for candidate in "${candidates[@]}"; do
+    [[ -x "$candidate" ]] && { printf '%s' "$candidate"; return 0; }
+  done
+  return 1
+}
+
+if [[ "${1:-}" == "--probe" ]]; then
+  if browser="$(find_browser)"; then
+    echo "renderer    $browser"
+    exit 0
+  fi
+  echo "renderer    no Chromium-based browser found - rendering unavailable" >&2
+  echo "            install Google Chrome, or set EDITABLE_DESIGN_BROWSER=<executable>" >&2
+  exit 1
+fi
+
+html="${1:?usage: render-poster.sh HTML [OUT_PNG] [--scale N | --dpi N]}"
+shift
+if [[ $# -gt 0 && "$1" != --* ]]; then
+  out="$1"
+  shift
+else
+  out="$(cd "$(dirname "$html")" 2>/dev/null && pwd)/out/poster.png"
+fi
+
+scale=""
+dpi=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --scale) scale="$2"; shift 2 ;;
+    --dpi) dpi="$2"; shift 2 ;;
+    *) echo "unknown argument: $1" >&2; exit 2 ;;
+  esac
+done
+
+test -f "$html" || { echo "no such file: $html" >&2; exit 2; }
+project="$(cd "$(dirname "$html")" && pwd)"
+config="$project/poster.json"
+
+# poster.json's shape is fixed by the starter, so sed is enough and this script
+# stays free of a JSON dependency.
+read_num() {
+  sed -n "s/.*\"$1\"[[:space:]]*:[[:space:]]*\([0-9][0-9]*\).*/\1/p" "$2" | head -1
+}
+
+if [[ -f "$config" ]]; then
+  width="$(read_num width "$config")"
+  height="$(read_num height "$config")"
+  [[ -z "$scale" ]] && scale="$(read_num scale "$config")"
+  [[ -z "$dpi" ]] && dpi="$(read_num dpi "$config")"
+fi
+
+[[ -n "${width:-}" && -n "${height:-}" ]] || {
+  echo "cannot read canvas.width / canvas.height from poster.json" >&2
+  exit 2
+}
+
+# Print path converts at 96 px/inch, so a given dpi decides the scale factor.
+if [[ -n "$dpi" && "$dpi" != "0" ]]; then
+  scale="$(awk -v d="$dpi" 'BEGIN { printf "%.4g", d / 96 }')"
+fi
+[[ -n "$scale" && "$scale" != "0" ]] || scale=2
+
+browser="$(find_browser)" || {
+  echo "no Chromium-based browser found. Set EDITABLE_DESIGN_BROWSER=<executable>" >&2
+  exit 1
+}
+
+mkdir -p "$(dirname "$out")"
+rm -f "$out"
+
+# Never attach to the user's running browser, and never share a profile between
+# poster renders. A shared profile makes concurrent jobs fight over its lock and
+# lets a stale Chrome child poison the next run.
+profile="$(mktemp -d "${TMPDIR:-/tmp}/poster-render-profile.XXXXXX")"
+renderer_pid=""
+
+profile_pids() {
+  ps -axo pid=,command= \
+    | awk -v marker="--user-data-dir=$profile" \
+        'index($0, marker) && index($0, "awk -v marker=") == 0 { print $1 }'
+}
+
+stop_renderer() {
+  local pids=""
+  local _
+
+  pids="$(profile_pids)"
+  [[ -n "$pids" ]] && kill $pids 2>/dev/null || true
+
+  for _ in $(seq 1 20); do
+    pids="$(profile_pids)"
+    [[ -z "$pids" ]] && break
+    sleep 0.1
+  done
+
+  pids="$(profile_pids)"
+  [[ -n "$pids" ]] && kill -KILL $pids 2>/dev/null || true
+
+  if [[ -n "$renderer_pid" ]]; then
+    wait "$renderer_pid" 2>/dev/null || true
+  fi
+}
+
+cleanup() {
+  stop_renderer
+  if [[ -n "$profile" && -d "$profile" && "$profile" == *"/poster-render-profile."* ]]; then
+    rm -rf -- "$profile"
+  fi
+}
+
+trap cleanup EXIT INT TERM
+
+"$browser" \
+  --headless \
+  --disable-gpu \
+  --hide-scrollbars \
+  --no-first-run \
+  --no-default-browser-check \
+  --disable-extensions \
+  --disable-background-networking \
+  --disable-sync \
+  --disable-default-apps \
+  --mute-audio \
+  --user-data-dir="$profile" \
+  --force-device-scale-factor="$scale" \
+  --window-size="${width},${height}" \
+  --screenshot="$out" \
+  "file://$(cd "$(dirname "$html")" && pwd)/$(basename "$html")" \
+  >/dev/null 2>&1 &
+renderer_pid=$!
+
+# headless occasionally does not exit on its own, so wait for the artefact
+# rather than for the process.
+for _ in $(seq 1 120); do
+  kill -0 "$renderer_pid" 2>/dev/null || break
+  [[ -s "$out" ]] && { sleep 0.4; break; }
+  sleep 0.5
+done
+stop_renderer
+renderer_pid=""
+
+test -s "$out" || { echo "render produced no $out" >&2; exit 3; }
+
+# A PNG's IHDR carries width and height at bytes 16..23, big-endian. Reading
+# them this way needs neither sips nor Pillow. macOS od emits a trailing blank
+# line, so split on words instead of processing line by line.
+png_dimensions() {
+  local file="$1"
+  # shellcheck disable=SC2046
+  set -- $(od -An -tu1 -j16 -N8 "$file")
+  printf '%d %d' \
+    "$(( $1 * 16777216 + $2 * 65536 + $3 * 256 + $4 ))" \
+    "$(( $5 * 16777216 + $6 * 65536 + $7 * 256 + $8 ))"
+}
+
+read -r actual_w actual_h <<<"$(png_dimensions "$out")"
+expect_w="$(awk -v w="$width" -v s="$scale" 'BEGIN { printf "%d", w * s + 0.5 }')"
+expect_h="$(awk -v h="$height" -v s="$scale" 'BEGIN { printf "%d", h * s + 0.5 }')"
+
+if [[ "$actual_w" != "$expect_w" || "$actual_h" != "$expect_h" ]]; then
+  echo "render does not match the declared canvas: got ${actual_w}x${actual_h}, expected ${expect_w}x${expect_h}" >&2
+  echo "canvas ${width}x${height} @${scale}x. Check that the root element's width/height equal its data-canvas-* values." >&2
+  exit 3
+fi
+
+echo "$out  ${actual_w}x${actual_h}  (canvas ${width}x${height} @${scale}x)"
+echo
+echo "Next: read this image and say every piece of text on it out loud, line by line."
+echo "Confirm nothing is clipped, covered, or carried in from the generated artwork."
+echo "A DOM check cannot see any of that."

package/skills/global_config/editable-design/scripts/trace.sh

@@ -0,0 +1,159 @@
+#!/usr/bin/env bash
+# Append-only execution trace for one poster build.
+#
+# Writes into `.trace/` inside the poster project: a manifest, one JSONL event
+# stream, per-step command output, and copies of intermediate artefacts. The
+# point is that "what was decided, and why" survives after the conversation is
+# gone — a rendered poster on its own cannot tell you which prompt produced its
+# backdrop or why a canvas size was chosen.
+#
+# Pure bash on purpose: this plugin has no runtime dependencies, and adding one
+# just to keep a log would be a bad trade.
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+project_root="$(cd "$script_dir/.." && pwd)"
+cd "$project_root"
+
+trace_dir="${POSTER_TRACE_DIR:-$project_root/.trace}"
+events="$trace_dir/events.jsonl"
+
+now() { date +"%Y-%m-%dT%H:%M:%S%z" | sed 's/\(..\)$/:\1/'; }
+
+# Minimal JSON string escaping: backslash, quote, then control characters.
+esc() {
+  printf '%s' "$1" \
+    | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' \
+    | awk 'BEGIN { ORS = "" } { if (NR > 1) print "\\n"; print }'
+}
+
+require_trace() {
+  test -f "$events" || {
+    echo "trace: no active trace. Run trace.sh init first" >&2
+    exit 2
+  }
+}
+
+append() {
+  require_trace
+  local seq
+  seq=$(( $(wc -l <"$events") + 1 ))
+  printf '{"seq":%d,"ts":"%s",%s}\n' "$seq" "$(now)" "$1" >>"$events"
+}
+
+cmd="${1:-}"
+shift || true
+
+case "$cmd" in
+  init)
+    label="${1:-}"
+    mkdir -p "$trace_dir/steps" "$trace_dir/artifacts"
+    : >"$events"
+    printf '{\n  "schema": "runlog/v1",\n  "run_id": "%s",\n  "created_at": "%s",\n  "skill": "poster-building",\n  "workspace": "%s",\n  "label": "%s",\n  "status": "running"\n}\n' \
+      "$(date +%Y%m%d-%H%M%S)" "$(now)" "$(esc "$PWD")" "$(esc "$label")" \
+      >"$trace_dir/manifest.json"
+    append "\"type\":\"run_start\",\"label\":\"$(esc "$label")\""
+    echo "$trace_dir"
+    ;;
+
+  start)
+    step="${1:?usage: trace.sh start STEP [TITLE]}"
+    append "\"type\":\"step_start\",\"step\":\"$(esc "$step")\",\"title\":\"$(esc "${2:-}")\""
+    ;;
+
+  done)
+    step="${1:?usage: trace.sh done STEP [STATUS] [NOTE]}"
+    append "\"type\":\"step_done\",\"step\":\"$(esc "$step")\",\"status\":\"${2:-ok}\",\"note\":\"$(esc "${3:-}")\""
+    ;;
+
+  decision)
+    key="${1:?usage: trace.sh decision KEY VALUE WHY [STEP]}"
+    value="${2:?}"
+    why="${3:?why is required — a decision without a reason is not worth recording}"
+    append "\"type\":\"decision\",\"step\":\"$(esc "${4:-}")\",\"key\":\"$(esc "$key")\",\"value\":\"$(esc "$value")\",\"why\":\"$(esc "$why")\""
+    ;;
+
+  note)
+    append "\"type\":\"note\",\"step\":\"$(esc "${2:-}")\",\"text\":\"$(esc "${1:?usage: trace.sh note TEXT [STEP]}")\""
+    ;;
+
+  artifact)
+    src="${1:?usage: trace.sh artifact PATH [STEP]}"
+    step="${2:-_unassigned}"
+    test -e "$src" || { echo "trace: no such path: $src" >&2; exit 2; }
+    dest="$trace_dir/artifacts/$step"
+    mkdir -p "$dest"
+    # -X drops extended attributes on macOS; GNU cp does not accept the same
+    # option, so keep the portable path everywhere else.
+    if [[ "$(uname -s)" == "Darwin" ]]; then
+      cp -RX "$src" "$dest/"
+    else
+      cp -R "$src" "$dest/"
+    fi
+    copied="$dest/$(basename "$src")"
+    find "$dest" -name '._*' -delete 2>/dev/null || true
+    if [[ -d "$copied" ]]; then
+      size=$(find "$copied" -type f -exec wc -c {} + | tail -1 | awk '{print $1}')
+    else
+      size=$(wc -c <"$copied" | tr -d ' ')
+    fi
+    append "\"type\":\"artifact\",\"step\":\"$(esc "$step")\",\"name\":\"$(esc "$(basename "$src")")\",\"path\":\"artifacts/$(esc "$step")/$(esc "$(basename "$src")")\",\"bytes\":$size"
+    ;;
+
+  run)
+    step="${1:?usage: trace.sh run STEP -- COMMAND...}"
+    shift
+    [[ "${1:-}" == "--" ]] && shift
+    [[ $# -gt 0 ]] || { echo "trace: no command given" >&2; exit 2; }
+
+    step_dir="$trace_dir/steps/$step"
+    mkdir -p "$step_dir"
+    index=$(( $(find "$step_dir" -name 'exec-*.json' | wc -l) + 1 ))
+    stem=$(printf 'exec-%02d' "$index")
+
+    append "\"type\":\"exec_start\",\"step\":\"$(esc "$step")\",\"label\":\"$stem\",\"command\":\"$(esc "$*")\""
+
+    started=$(date +%s)
+    set +e
+    "$@" >"$step_dir/$stem.stdout" 2>"$step_dir/$stem.stderr"
+    code=$?
+    set -e
+    elapsed=$(( $(date +%s) - started ))
+
+    printf '{\n  "label": "%s",\n  "command": "%s",\n  "exit_code": %d,\n  "duration_s": %d,\n  "stdout": "%s.stdout",\n  "stderr": "%s.stderr"\n}\n' \
+      "$stem" "$(esc "$*")" "$code" "$elapsed" "$stem" "$stem" >"$step_dir/$stem.json"
+
+    append "\"type\":\"exec_done\",\"step\":\"$(esc "$step")\",\"label\":\"$stem\",\"exit_code\":$code,\"duration_s\":$elapsed"
+
+    cat "$step_dir/$stem.stdout"
+    cat "$step_dir/$stem.stderr" >&2
+    exit $code
+    ;;
+
+  finish)
+    require_trace
+    status="${1:-ok}"
+    append "\"type\":\"run_finish\",\"status\":\"$status\""
+    sed -i.bak "s/\"status\": \"running\"/\"status\": \"$status\"/" "$trace_dir/manifest.json"
+    rm -f "$trace_dir/manifest.json.bak"
+    printf '{\n  "status": "%s",\n  "finished_at": "%s",\n  "events": %d\n}\n' \
+      "$status" "$(now)" "$(wc -l <"$events")" >"$trace_dir/result.json"
+    echo "$trace_dir"
+    ;;
+
+  *)
+    cat >&2 <<'USAGE'
+usage: trace.sh <command>
+
+  init [LABEL]                     start a trace in ./.trace/
+  start STEP [TITLE]               mark a step as started
+  done STEP [ok|skip|fail] [NOTE]  mark a step as finished
+  decision KEY VALUE WHY [STEP]    record a choice and its reason (why is required)
+  note TEXT [STEP]                 record an observation
+  artifact PATH [STEP]             copy an intermediate artefact into the trace
+  run STEP -- COMMAND...           run a command, capturing output and exit code
+  finish [ok|fail]                 close the trace
+USAGE
+    exit 2
+    ;;
+esac

package/skills/global_config/editable-design/scripts/verify-replay.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import vm from 'node:vm';
+
+const input = resolve(process.argv[2] || join(process.cwd(), 'replay', 'index.html'));
+const replayDir = dirname(input);
+const required = ['index.html', 'replay.css', 'replay.js', 'replay-motion.js', 'data.js'];
+let failed = false;
+
+for (const file of required) {
+  const ok = existsSync(join(replayDir, file));
+  console.log(` ${ok ? '✅' : '❌'} ${file}`);
+  failed ||= !ok;
+}
+
+if (!failed) {
+  const html = readFileSync(input, 'utf8');
+  const replayCSS = readFileSync(join(replayDir, 'replay.css'), 'utf8');
+  const replayJS = readFileSync(join(replayDir, 'replay.js'), 'utf8');
+  const motionJS = readFileSync(join(replayDir, 'replay-motion.js'), 'utf8');
+  const script = readFileSync(join(replayDir, 'data.js'), 'utf8');
+  const sandbox = { window: {} };
+  vm.runInNewContext(script, sandbox, { timeout: 1000 });
+  const data = sandbox.window.__POSTER_REPLAY__;
+  const ids = data?.stages?.map((stage) => stage.id) || [];
+  const expected = ['input', 'reference', 'plan', 'assets', 'html', 'review', 'layers'];
+  const schemaOK = data?.schema === 'poster-replay/v1';
+  const stagesOK = expected.every((id, index) => ids[index] === id);
+  const offlineOK = !/https?:\/\//i.test(html) && !/\bfetch\s*\(/.test(replayJS) && !/\bfetch\s*\(/.test(motionJS);
+  const sourceOK = data.stages.every((stage) => Array.isArray(stage.sources));
+  const phaseNavOK = html.includes('id="phase-nav"') && ['理解与规划', '生成与构建', '观察与修正'].every((label) => html.includes(label));
+  const phaseIconsOK = ['icons/plan.png', 'icons/html.png', 'icons/review.png'].every((source) => html.includes(source));
+  const noDefaultDetailOK = !html.includes('data-default-stage') && replayJS.includes('document.body.dataset.defaultStage ? stageById.get(document.body.dataset.defaultStage) : null');
+  const arrowSizingOK = /markerUnits=["']userSpaceOnUse["']/.test(replayJS);
+  const motionOK = html.includes('id="play-replay"') && ['runIntro', 'startAmbient', 'playReplay'].every((name) => motionJS.includes(name));
+  const reducedMotionOK = motionJS.includes('prefers-reduced-motion');
+  const flowIds = ['flow-input-reference', 'flow-reference-plan', 'flow-plan-assets', 'flow-assets-html', 'flow-html-review', 'flow-review-html-repair', 'flow-review-layers'];
+  const playbackPathOK = flowIds.every((id) => replayJS.includes(`id="${id}"`) && motionJS.includes(id));
+  const ambientCadenceOK = motionJS.includes('randomBetween(1800, 3000)') && motionJS.includes('randomBetween(2600, 4000)') && motionJS.includes('isRepair ? 1100 : 400') && motionJS.includes('strong ? 720 : 1150') && motionJS.includes('scale >= .20');
+  const introTimingOK = motionJS.includes('INTRO_DURATION = 4700') && replayCSS.includes('.is-intro .detail-panel');
+  const assetOverviewOK = replayJS.includes('asset-overview-grid') && replayCSS.includes('.asset-overview-grid');
+  const planMatrixOK = replayJS.includes('hasRecordedRects') && replayJS.includes('slots.length >= 5 ? 3') && replayJS.includes('slot.role || slot.form || slot.aspect || slot.prompt') && replayJS.includes('plan-empty');
+  const scaledPhaseNavOK = html.indexOf('id="canvas-world"') < html.indexOf('id="phase-nav"') && html.indexOf('id="phase-nav"') < html.indexOf('id="flow-lines"') && replayCSS.includes('width: 2540px');
+  const largePhaseNavOK = replayCSS.includes('width: 210px') && replayCSS.includes('min-height: 210px') && replayCSS.includes('width: 56px; height: 56px') && replayCSS.includes('font-size: 19px');
+  const assetStageOK = replayJS.includes("assets:    { x: 800,  y: 640,  w: 480, h: 390 }") && replayJS.includes("shorten(first.prompt || '未记录素材 Prompt。', 320)");
+  const adaptiveAssetsOK = replayJS.includes('assetItems.length === 1') && replayJS.includes("className: 'asset single-asset'") && replayJS.includes('x: 260, y: 610, w: 500, h: 440') && replayJS.includes('x: 260 + (index % 2) * 260') && replayJS.includes('y: 610 + Math.floor(index / 2) * 230') && replayJS.includes('assetCount === 1') && replayJS.includes('.slice(0, assetCount)');
+  const assetShowcaseOK = motionJS.includes('scheduleAssetShowcase') && motionJS.includes('duration: 700') && motionJS.includes('randomBetween(4000, 6000)') && motionJS.includes("transform: 'scale(1.015)'");
+  const feedbackLabelOK = replayJS.includes('class="flow-label prove-label"') && replayCSS.includes('.flow-label text { fill: #47765c');
+  const layersStage = data.stages.find((stage) => stage.id === 'layers');
+  const liveLayerAnimationOK = !layersStage?.preview?.includes('motion=0') && replayJS.includes('可编辑分层动画（HTML）');
+  const synchronizedLayerAnimationOK = replayJS.includes('data-animation-src') && replayJS.includes('restartLayerAnimation') && replayJS.includes("id === 'layers'") && motionJS.includes('wait(3650)');
+  const motionHandshakeOK = replayJS.includes('__POSTER_REPLAY_VIEWER__') && motionJS.includes('__POSTER_REPLAY_VIEWER__') && motionJS.includes("document.body.dataset.motionState = 'recovered'");
+  const referencePlacementOK = replayJS.includes("reference: { x: 820,  y: 110,  w: 450, h: 330 }") && replayJS.includes("x: 1538, y: 110, w: 270, h: 360") && replayJS.includes('class="flow-artifact flow-path think"') && replayJS.includes('d="M1270 290 L2075 290"') && !replayJS.includes('L1900 70 C2030 70 2010 275 2075 275');
+  const rightColumnPlanOK = replayJS.includes("plan:      { x: 2075, y: 110,  w: 420, h: 360 }") && replayJS.includes("x: 2075, y: 670, w: 420, h: 560") && replayJS.includes("x: 2075, y: 1320, w: 420, h: 360");
+  const featuredMediaOK = replayJS.includes("x: 2075, y: 670, w: 420, h: 560") && replayJS.includes("x: 2075, y: 1320, w: 420, h: 360");
+  const detailPanelOK = replayCSS.includes('width: min(620px, calc(100vw - 36px))') && replayCSS.includes('#detail-content { display: flex') && replayCSS.includes('overflow-y: auto') && replayJS.includes("event.target.closest('.detail-panel,.media-lightbox')");
+  const mediaLightboxOK = html.includes('id="media-lightbox"') && ['openMode: \'image\'', "openMode: 'animation'", 'url.searchParams.delete(\'motion\')'].every((token) => replayJS.includes(token)) && replayCSS.includes('.media-lightbox.is-open');
+  const fullPngContainOK = replayCSS.includes('.media-lightbox-frame img { display: block; width: auto; height: auto; max-width: 100%; max-height: 100%; min-width: 0; min-height: 0; object-fit: contain; }');
+  console.log(` ${schemaOK ? '✅' : '❌'} poster-replay/v1 schema`);
+  console.log(` ${stagesOK ? '✅' : '❌'} seven ordered creative stages`);
+  console.log(` ${offlineOK ? '✅' : '❌'} offline file:// runtime`);
+  console.log(` ${sourceOK ? '✅' : '❌'} source provenance on every stage`);
+  console.log(` ${phaseNavOK ? '✅' : '❌'} three persistent phase controls`);
+  console.log(` ${phaseIconsOK ? '✅' : '❌'} phase control icons`);
+  console.log(` ${noDefaultDetailOK ? '✅' : '❌'} clean overview with no default detail`);
+  console.log(` ${arrowSizingOK ? '✅' : '❌'} bounded flow-arrow markers`);
+  console.log(` ${motionOK ? '✅' : '❌'} intro, ambient, and playback motion states`);
+  console.log(` ${reducedMotionOK ? '✅' : '❌'} reduced-motion fallback`);
+  console.log(` ${playbackPathOK ? '✅' : '❌'} playback path-to-stage mapping`);
+  console.log(` ${ambientCadenceOK ? '✅' : '❌'} faster ambient and repair cadence`);
+  console.log(` ${introTimingOK ? '✅' : '❌'} 4.7s intro with hidden detail panel`);
+  console.log(` ${assetOverviewOK ? '✅' : '❌'} all-assets visual overview`);
+  console.log(` ${planMatrixOK ? '✅' : '❌'} recorded-plan slot matrix fallback`);
+  console.log(` ${scaledPhaseNavOK ? '✅' : '❌'} phase controls scale with the canvas world`);
+  console.log(` ${largePhaseNavOK ? '✅' : '❌'} enlarged readable phase controls`);
+  console.log(` ${assetStageOK ? '✅' : '❌'} compact Assets stage with Prompt summary`);
+  console.log(` ${adaptiveAssetsOK ? '✅' : '❌'} adaptive single/full and multi 2x2 Assets previews`);
+  console.log(` ${assetShowcaseOK ? '✅' : '❌'} 700ms Assets gallery showcase with 4-6s rest`);
+  console.log(` ${feedbackLabelOK ? '✅' : '❌'} feedback label on green observation path`);
+  console.log(` ${liveLayerAnimationOK ? '✅' : '❌'} live HTML layer animation`);
+  console.log(` ${synchronizedLayerAnimationOK ? '✅' : '❌'} layer animation synchronized with intro and playback`);
+  console.log(` ${motionHandshakeOK ? '✅' : '❌'} resilient motion initialization handshake`);
+  console.log(` ${referencePlacementOK ? '✅' : '❌'} centered reference on a straight dashed connector`);
+  console.log(` ${rightColumnPlanOK ? '✅' : '❌'} Design Plan aligned with the right output column`);
+  console.log(` ${featuredMediaOK ? '✅' : '❌'} enlarged right-side output column`);
+  console.log(` ${detailPanelOK ? '✅' : '❌'} wide independently scrolling detail panel`);
+  console.log(` ${mediaLightboxOK ? '✅' : '❌'} image and animation lightbox behaviors`);
+  console.log(` ${fullPngContainOK ? '✅' : '❌'} full uncropped PNG in image lightbox`);
+  failed ||= !schemaOK || !stagesOK || !offlineOK || !sourceOK || !phaseNavOK || !phaseIconsOK || !noDefaultDetailOK || !arrowSizingOK || !motionOK || !reducedMotionOK || !playbackPathOK || !ambientCadenceOK || !introTimingOK || !assetOverviewOK || !planMatrixOK || !scaledPhaseNavOK || !largePhaseNavOK || !assetStageOK || !adaptiveAssetsOK || !assetShowcaseOK || !feedbackLabelOK || !liveLayerAnimationOK || !synchronizedLayerAnimationOK || !motionHandshakeOK || !referencePlacementOK || !rightColumnPlanOK || !featuredMediaOK || !detailPanelOK || !mediaLightboxOK || !fullPngContainOK;
+
+  const missing = data.stages.filter((stage) => /缺失|不完整|未生成/.test(stage.statusLabel));
+  if (missing.length) console.log(` ⚠️  missing evidence is shown, not reconstructed: ${missing.map((stage) => stage.id).join(', ')}`);
+}
+
+if (failed) process.exit(1);
+console.log(`\n✅ Replay contract passed: ${input}\n`);