File size: 26,021 Bytes
68e2686
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
#!/usr/bin/env python3
"""teaser · 编辑 case 的「外观编辑 + 动作 / 轨迹控制」编排(maliang venv,CPU)。目标:展示「语义管布局、首帧管外观、按键管动作」
三者可以分开控制。产物都在 outputs/teaser/edit/app/(下称 $A)。

子命令
------
plan       底子(BASES:A 档首帧 + vscore 高 + 无硬伤的双向 rollout,见 outputs/teaser/roll/<name>)→ $A/bases.json,
           外观编辑的首帧任务 → $A/f0/jobs.jsonl(edit_app_f0.py 吃;每个底子 7–8 个变体:时间 / 天气 / 季节整图编辑、
           主角换盔甲 / 换英雄、Boss 换造型、地面换材质)。
galleryplan 角色画廊(GALLERY:3 个底子 × 6 种主角、3 个底子 × 6 种 Boss,kind = char 局部编辑)→ $A/f0/gallery.jsonl;
           rolljobs 会把画好的写进 $A/jobs_extra.jsonl。
rolljobs   已编辑好的首帧 → 双向 rollout 任务 $A/jobs_look.jsonl(rollout.py 吃;ids / prompts = 底子原样,只换首帧;
           每个底子另加一条 orig = 原首帧,同一流水线重跑,宫格对照用)。
mirror     镜像 = 动作控制:底子的 ids 与首帧左右镜像(ids[:, :, ::-1],左右部件 id 互换:12↔13、14↔15、17↔18、19↔20 ⇒ 镜像后的
           角色仍是解剖上一致的人),按键 a / d 互换、prompts 按新按键重写 ⇒「同一个世界、往反方向走」→ $A/inputs/mirror/<b>/;
           另做 text 换动作:ids / 首帧不动,只把 21 条 prompts 换成别的动作文本(全 standing still / 反向 / 一直攻击)→
           $A/inputs/text/<b>/。任务写进 $A/jobs_act.jsonl。
finalize   每条完成的结果目录补齐:first.png(实际首帧)、actions.npy([20,5] w a s d attack;编辑改了动作就是新的)、
           prompts.json(21 条)、ids.npz(rollout.py 已写)、meta.json 里加 "edit" 键(编辑类型、编辑帧、编辑参数、底子来源)。
compose    $A/showcase/:每个底子「原版 + 各外观变体」宫格(look_<b>.mp4)、全部外观的总宫格、镜像 / 文本对照并排、
           帧拼图 jpg($A/showcase/sheets/)。同一世界不同游玩的合成在 edit_sameworld.py compose。

usage($PY = $M/.venv/bin/python + SPEC §0 的 env;在 $M 下运行):
  $PY scripts/teaser/edit_app.py plan
  CUDA_VISIBLE_DEVICES=6 $M/envs/img/bin/python scripts/teaser/edit_app_f0.py --jobs outputs/teaser/edit/app/f0/jobs.jsonl
  $PY scripts/teaser/edit_app.py rolljobs && $PY scripts/teaser/edit_app.py mirror
  CUDA_VISIBLE_DEVICES=7 nohup $PY scripts/teaser/rollout.py --jobs outputs/teaser/edit/app/jobs_look.jsonl \\
      outputs/teaser/edit/app/jobs_act.jsonl --compile --watch 600 > outputs/teaser/logs/edit/roll_g7.log 2>&1 &
  $PY scripts/teaser/edit_app.py finalize && $PY scripts/teaser/edit_app.py compose
"""
from __future__ import annotations

import argparse
import glob
import json
import os
import shutil
import sys

import numpy as np

M = "/opt/dlami/nvme/zhiyangdeng/maliang"
HERE = os.path.dirname(os.path.abspath(__file__))
for _p in (f"{M}/code/gc25d", HERE):
    if _p not in sys.path:
        sys.path.insert(0, _p)

A = f"{M}/outputs/teaser/edit/app"
ROLL = f"{M}/outputs/teaser/roll"

# ------------------------------------------------------------------ 编辑变体 ----
GLOBAL = {
    "night": "Change only the time of day of picture 1 to a dark moonlit night: cool deep-blue moonlight over the whole "
             "scene, dark soft night shadows, and a few warm orange lights glowing from existing windows, lanterns and "
             "braziers.",
    "dusk": "Change only the lighting of picture 1 to a warm sunset at dusk: low golden-orange sunlight from one side, long "
            "soft shadows and a pink-purple evening glow over the whole scene.",
    "snow": "Turn picture 1 into deep winter: a thick layer of fresh white snow covers all the open ground, the floors and "
            "paths, the roofs, the tops of walls, the rocks and the plants; frost and icicles; cold soft winter light.",
    "autumn": "Turn picture 1 into late autumn: every tree, bush and patch of grass turns red, orange and golden, and fallen "
              "autumn leaves are scattered over the ground and paths; warm soft autumn light.",
    "spring": "Turn picture 1 into fresh spring: the grass becomes lush bright green, the trees and bushes are covered in "
              "pink and white blossoms and fresh green leaves, petals are scattered on the ground; soft bright morning light.",
    "lava": "Turn picture 1 from ice into fire: every ice surface becomes dark volcanic rock and every frozen water surface "
            "becomes glowing molten orange lava; the ice walls become black basalt with glowing cracks; hot red-orange light.",
}
CHAR = {
    "hero_gold": ("player", "Edit picture 1: the hero warrior in the middle now wears ornate shining golden plate armour "
                            "with a flowing red cape and a golden helmet, still holding the same sword."),
    "hero_swap": ("player", "Edit picture 1: replace the hero warrior in the middle with a different hero: a battle mage in "
                            "long flowing crimson robes with a pointed hood and glowing blue magic runes, holding a glowing "
                            "blue sword in the same hand."),
    "boss_swap": ("boss", "Edit picture 1: replace the big monster boss with a different boss: a huge undead skeleton giant "
                          "made of bleached bones, with glowing blue eyes and tattered black cloth, wielding the same kind of "
                          "big weapon."),
}
# 地面换材质:每个底子各自的 (classes, 提示词)
GROUND = {
    "farm": ((2,), "Change only the grey gravel ground and tracks in picture 1 into bright red brick paving."),
    "egypt_sc": ((2,), "Change only the large cracked sandstone floor slabs in picture 1 into polished black-and-white "
                       "checkered marble tiles."),
    "egypt_fl": ((1,), "Change only the golden desert sand in picture 1 into lush green meadow grass."),
    "tibetan": ((2,), "Change only the light grey stone-paved courtyard floor in picture 1 into a soft green grass lawn."),
    "greek": ((2,), "Change only the white marble floor slabs in picture 1 into dark red terracotta floor tiles."),
    "oasis": ((1,), "Change only the golden desert sand in picture 1 into lush green meadow grass."),
    "samurai": ((2,), "Change only the dark grey stone-paved floor in picture 1 into raked white zen garden gravel."),
    "harvest": ((1,), "Change only the trampled brown-yellow grass ground in picture 1 into fresh white snow."),
    "rice": ((1,), "Change only the green terraced rice fields in picture 1 into golden ripe rice fields ready for harvest."),
    "icecave": ((2,), "Change only the smooth translucent blue ice floor in picture 1 into glowing molten lava rock floor."),
}
SEED = {"night": 11, "dusk": 12, "snow": 13, "autumn": 14, "spring": 15, "lava": 16, "hero_gold": 21, "hero_swap": 22,
        "boss_swap": 23, "ground": 31}
STD = ["night", "dusk", "snow", "autumn", "hero_gold", "hero_swap", "boss_swap", "ground"]
BASES = [   # (短名, 底子 rollout 名, 变体)
    ("farm", "ruins__P9C_default_s9945__000096__s4002__farm@photoreal", STD),
    ("egypt_sc", "stonecircle__P9_golden_s7905__001344__s6005__egypt@cinematic", STD),
    ("egypt_fl", "farmland__R10_s9503__004032__s9006__egypt@photoreal", STD),
    ("tibetan", "maze__R10_s3505__003552__s6__tibetan@photoreal", STD),
    ("greek", "colonnade__P9C_default_s10942__001536__s5009__greek@photoreal", [v for v in STD if v != "boss_swap"]),
    ("oasis", "orchard__R10_s6509__001824__s18__oasis@cinematic", [v for v in STD if v != "boss_swap"]),
    ("samurai", "maze__P9_golden_s2907__003648__s11__samurai@photoreal", STD),
    ("harvest", "farmland__R10_s3512__003072__s9012__autumn_harvest@photoreal",
     ["night", "dusk", "snow", "spring", "hero_gold", "hero_swap", "boss_swap", "ground"]),
    ("rice", "patchwork__R10_s3505__003552__s6__rice_terraces@cinematic", STD),
    ("icecave", "arena__P9_golden_s7905__001344__s7000__icecave@photoreal",
     ["night", "dusk", "lava", "hero_gold", "hero_swap", "boss_swap", "ground"]),
]
EDIT_DESC = {"night": "time of day → moonlit night", "dusk": "time of day → sunset", "snow": "weather → snow",
             "autumn": "season → autumn", "spring": "season → spring", "lava": "material → ice to lava",
             "hero_gold": "hero → golden armour", "hero_swap": "hero → crimson battle mage", "boss_swap":
             "boss → skeleton giant", "ground": "ground material", "orig": "original first frame"}
EDIT_EN = {"orig": "Original", "night": "Night", "dusk": "Sunset", "snow": "Snow", "autumn": "Autumn", "spring": "Spring",
           "lava": "Ice to Lava", "hero_gold": "Golden Armour", "hero_swap": "New Hero", "boss_swap": "New Boss",
           "ground": "New Ground"}
SWAP_LR = {12: 13, 13: 12, 14: 15, 15: 14, 17: 18, 18: 17, 19: 20, 20: 19}


def rp(p: str) -> str:
    return p if os.path.isabs(p) else os.path.join(M, p)


def base_info(short: str, name: str) -> dict:
    meta = json.load(open(f"{ROLL}/{name}/meta.json"))
    j = meta["job"]
    md = os.path.dirname(j["ids"])
    vs = f"{M}/outputs/teaser/vscore/roll/{name}.vscore.json"
    v = json.load(open(vs)) if os.path.exists(vs) else {}
    return {"short": short, "name": name, "roll": f"{ROLL}/{name}", "first": j["first"], "ids": j["ids"],
            "prompts": j["prompts"], "actions": f"{md}/actions.npy", "map_dir": md, "scene": j.get("scene"),
            "map": j.get("map"), "case": os.path.basename(md), "vscore": v.get("teaser"), "flags": v.get("flags")}


def load_bases() -> dict:
    return {b["short"]: b for b in json.load(open(f"{A}/bases.json"))}


# ------------------------------------------------------------------ plan ----
def cmd_plan(a) -> None:
    os.makedirs(f"{A}/f0", exist_ok=True)
    bases = [base_info(s, n) | {"variants": vs} for s, n, vs in BASES]
    json.dump(bases, open(f"{A}/bases.json", "w"), indent=1)
    rows = []
    for b in bases:
        for v in b["variants"]:
            j = {"out": f"{A}/f0/{b['short']}/{v}.png", "src": b["first"], "ids": b["ids"], "seed": SEED[v],
                 "base": b["name"], "short": b["short"], "variant": v}
            if v in GLOBAL:
                j.update(kind="global", prompt=GLOBAL[v])
            elif v in CHAR:
                j.update(kind="char", target=CHAR[v][0], prompt=CHAR[v][1])
            elif v == "ground":
                cls, p = GROUND[b["short"]]
                j.update(kind="ground", classes=list(cls), prompt=p)
            rows.append(j)
    with open(f"{A}/f0/jobs.jsonl", "w") as fh:
        for r in rows:
            fh.write(json.dumps(r, ensure_ascii=False) + "\n")
    print(f"{len(bases)} 个底子 → {A}/bases.json;{len(rows)} 个首帧编辑任务 → {A}/f0/jobs.jsonl")


# ------------------------------------------------------------------ rolljobs ----
def roll_row(name: str, first: str, ids: str, prompts, edit: dict, prio: float = 0, out: str = f"{A}/roll") -> dict:
    return {"name": name, "first": first, "ids": ids, "prompts": prompts, "out": out, "seed": 0, "prio": prio,
            "label": edit.get("label"), "scene": edit.get("scene"), "map": edit.get("map"), "edit": edit}


# ------------------------------------------------------------------ 角色画廊(同一张图 × 多种主角 / Boss) ----
HEROES = {
    "h_paladin": "a holy paladin in shining white-and-gold plate armour with a blue tabard",
    "h_ninja": "a black-clad ninja assassin with a dark hood and a face mask",
    "h_ranger": "an elven ranger in green leather armour with a hooded green cloak",
    "h_barbarian": "a muscular barbarian with bare arms, brown fur pelts and a horned helmet",
    "h_crimson": "a knight in dark crimson plate armour with a long black cape",
    "h_samurai": "a samurai in red-and-black lacquered armour with a horned kabuto helmet",
}
BOSSES = {
    "b_golem": "a huge golem made of mossy grey stone blocks with glowing green cracks",
    "b_demon": "a huge fire demon with dark red skin, big horns and glowing orange cracks",
    "b_troll": "a huge ice troll with pale blue skin, white hair and frost on its shoulders",
    "b_minotaur": "a huge brown-furred minotaur with big curved horns and a nose ring",
    "b_orc": "a huge green-skinned orc warlord in spiked black iron armour",
    "b_insect": "a huge armoured insect monster with a glossy purple carapace and many legs",
}
GALLERY = {"greek": "hero", "samurai": "hero", "tibetan": "hero", "rice": "boss", "farm": "boss", "egypt_sc": "boss"}
GAL_EN = {"h_paladin": "Paladin", "h_ninja": "Ninja", "h_ranger": "Elf Ranger", "h_barbarian": "Barbarian",
          "h_crimson": "Crimson Knight", "h_samurai": "Samurai", "b_golem": "Stone Golem", "b_demon": "Fire Demon",
          "b_troll": "Ice Troll", "b_minotaur": "Minotaur", "b_orc": "Orc Warlord", "b_insect": "Insect Monster"}
EDIT_EN.update(GAL_EN)


def gallery_variants(short: str) -> list[str]:
    return list(HEROES if GALLERY.get(short) == "hero" else BOSSES) if short in GALLERY else []


def cmd_galleryplan(a) -> None:
    """角色画廊的首帧编辑任务 → $A/f0/gallery.jsonl(edit_app_f0 吃,kind = char)。"""
    bases = load_bases()
    rows = []
    for s, who in GALLERY.items():
        b = bases[s]
        for i, v in enumerate(gallery_variants(s)):
            if who == "hero":
                p = (f"Edit picture 1: replace the hero warrior in the middle with a different hero: {HEROES[v]}, holding "
                     "the same sword in the same hand.")
            else:
                p = (f"Edit picture 1: replace the big monster boss with a different boss: {BOSSES[v]}, wielding the same "
                     "kind of big weapon.")
            rows.append({"out": f"{A}/f0/{s}/{v}.png", "src": b["first"], "ids": b["ids"], "seed": 41 + i, "base": b["name"],
                         "short": s, "variant": v, "kind": "char", "target": "player" if who == "hero" else "boss",
                         "prompt": p})
    with open(f"{A}/f0/gallery.jsonl", "w") as fh:
        for r in rows:
            fh.write(json.dumps(r, ensure_ascii=False) + "\n")
    print(f"{len(rows)} 个角色画廊首帧任务 → {A}/f0/gallery.jsonl")


def cmd_rolljobs(a) -> None:
    bases = load_bases()
    rows = []
    for b in bases.values():
        common = {"base": b["name"], "base_roll": b["roll"], "map_dir": b["map_dir"], "scene": b["scene"], "map": b["map"]}
        rows.append(roll_row(f"{b['short']}__orig", b["first"], b["ids"], b["prompts"],
                             common | {"type": "appearance", "variant": "orig", "edit_frame": None,
                                       "label": EDIT_EN["orig"], "desc": EDIT_DESC["orig"]}, prio=2))
        for v in b["variants"]:
            png = f"{A}/f0/{b['short']}/{v}.png"
            if not (os.path.exists(png) and os.path.exists(png[:-4] + ".json")):
                continue
            info = json.load(open(png[:-4] + ".json"))
            j = info["job"]
            ed = common | {"type": "appearance", "variant": v, "kind": j["kind"], "edit_frame": 0, "first_src": b["first"],
                           "edit_prompt": info["prompt"], "edit_seed": j["seed"], "editor": "Qwen-Image-2.1-Turbo",
                           "target": j.get("target"), "classes": j.get("classes"), "label": EDIT_EN[v],
                           "desc": EDIT_DESC[v], "struct": info.get("struct")}
            rows.append(roll_row(f"{b['short']}__{v}", png, b["ids"], b["prompts"], ed, prio=1))
    with open(f"{A}/jobs_look.jsonl", "w") as fh:
        for r in rows:
            fh.write(json.dumps(r, ensure_ascii=False) + "\n")
    print(f"{len(rows)} 个外观 rollout 任务 → {A}/jobs_look.jsonl")
    extra = []                                                       # 角色画廊 → jobs_extra.jsonl
    for s in GALLERY:
        b = bases[s]
        common = {"base": b["name"], "base_roll": b["roll"], "map_dir": b["map_dir"], "scene": b["scene"], "map": b["map"]}
        for v in gallery_variants(s):
            png = f"{A}/f0/{s}/{v}.png"
            if not (os.path.exists(png) and os.path.exists(png[:-4] + ".json")):
                continue
            info = json.load(open(png[:-4] + ".json"))
            j = info["job"]
            ed = common | {"type": "appearance", "variant": v, "kind": "char", "gallery": True, "edit_frame": 0,
                           "first_src": b["first"], "edit_prompt": info["prompt"], "edit_seed": j["seed"],
                           "editor": "Qwen-Image-2.1-Turbo", "target": j["target"], "label": GAL_EN[v],
                           "desc": f"{j['target']} -> {GAL_EN[v]}", "struct": info.get("struct")}
            extra.append(roll_row(f"{s}__{v}", png, b["ids"], b["prompts"], ed, prio=0.8))
    with open(f"{A}/jobs_extra.jsonl", "w") as fh:
        for r in extra:
            fh.write(json.dumps(r, ensure_ascii=False) + "\n")
    print(f"{len(extra)} 个角色画廊 rollout 任务 → {A}/jobs_extra.jsonl")


# ------------------------------------------------------------------ mirror / text ----
def mirror_ids(ids: np.ndarray) -> np.ndarray:
    out = ids[:, :, ::-1].copy()
    lut = np.arange(256, dtype=np.uint8)
    for k, v in SWAP_LR.items():
        lut[k] = v
    return lut[out]


def blocks_to_prompts(blocks20: np.ndarray) -> list[str]:
    import text as TXT
    return TXT.cell_prompts(blocks20)


MIRROR_BASES = ["farm", "egypt_sc", "tibetan", "greek", "samurai", "harvest", "rice", "icecave", "oasis", "egypt_fl"]
TEXT_BASES = ["farm", "tibetan", "greek", "samurai", "harvest", "icecave"]
TEXT_VARIANTS = {   # 名字 → blocks20 的变换([20,5] w a s d attack)
    "still": lambda b: np.zeros_like(b),
    "reverse": lambda b: b[:, [2, 3, 0, 1, 4]],              # w↔s、a↔d(文本说反方向走)
    "attack": lambda b: np.concatenate([b[:, :4], np.ones_like(b[:, 4:])], 1),
}
TEXT_EN = {"still": "Text: standing still", "reverse": "Text: opposite direction", "attack": "Text: always attacking"}


def cmd_mirror(a) -> None:
    import cv2
    bases = load_bases()
    rows = []
    for s in MIRROR_BASES:
        b = bases[s]
        d = f"{A}/inputs/mirror/{s}"
        os.makedirs(d, exist_ok=True)
        with np.load(b["ids"]) as z:
            ids = z["ids"]
        np.savez_compressed(f"{d}/ids.npz", ids=mirror_ids(ids))
        img = cv2.imread(b["first"])
        cv2.imwrite(f"{d}/first.png", img[:, ::-1])
        blocks = np.load(b["actions"])
        mb = blocks[:, [0, 3, 2, 1, 4]].copy()                       # a↔d
        np.save(f"{d}/actions.npy", mb)
        json.dump(blocks_to_prompts(mb), open(f"{d}/prompts.json", "w"), indent=1)
        common = {"base": b["name"], "base_roll": b["roll"], "map_dir": b["map_dir"], "scene": b["scene"], "map": b["map"]}
        rows.append(roll_row(f"{s}__mirror", f"{d}/first.png", f"{d}/ids.npz", f"{d}/prompts.json",
                             common | {"type": "action", "variant": "mirror", "edit_frame": 0,
                                       "desc": "ids + first frame mirrored left↔right (L/R part ids swapped), keys a↔d",
                                       "label": "Mirrored (A/D swapped)", "actions": f"{d}/actions.npy"}, prio=1.5))
        # 镜像对照:镜像语义 + 原首帧不镜像?不做(首帧与语义矛盾)。原版 = <s>__orig(jobs_look 里已有)
    for s in TEXT_BASES:
        b = bases[s]
        blocks = np.load(b["actions"])
        common = {"base": b["name"], "base_roll": b["roll"], "map_dir": b["map_dir"], "scene": b["scene"], "map": b["map"]}
        for tv, fn in TEXT_VARIANTS.items():
            d = f"{A}/inputs/text/{s}/{tv}"
            os.makedirs(d, exist_ok=True)
            nb = fn(blocks).astype(np.uint8)
            np.save(f"{d}/actions.npy", nb)
            json.dump(blocks_to_prompts(nb), open(f"{d}/prompts.json", "w"), indent=1)
            rows.append(roll_row(f"{s}__text_{tv}", b["first"], b["ids"], f"{d}/prompts.json",
                                 common | {"type": "action", "variant": f"text_{tv}", "edit_frame": 0,
                                           "desc": f"only the 21 action prompts replaced ({tv}); ids and first frame unchanged",
                                           "label": TEXT_EN[tv], "actions": f"{d}/actions.npy"}, prio=0.5))
    with open(f"{A}/jobs_act.jsonl", "w") as fh:
        for r in rows:
            fh.write(json.dumps(r, ensure_ascii=False) + "\n")
    print(f"{len(rows)} 个镜像 / 文本 rollout 任务 → {A}/jobs_act.jsonl")


# ------------------------------------------------------------------ finalize ----
def finalize_dir(od: str) -> bool:
    """补齐一条结果目录:first.png / actions.npy / prompts.json / meta.json 的 edit 键。返回是否改动。"""
    mp = f"{od}/meta.json"
    if not os.path.exists(mp):
        return False
    meta = json.load(open(mp))
    j = meta.get("job") or {}                                         # edit_long.py 的结果没有 job(自己写全了文件和 edit 键)
    ed = j.get("edit") or meta.get("edit") or {}
    changed = False
    if not os.path.exists(f"{od}/first.png") and j.get("first"):
        import cv2
        img = cv2.imread(rp(j["first"]))
        cv2.imwrite(f"{od}/first.png", img)
        changed = True
    if not os.path.exists(f"{od}/prompts.json"):
        json.dump(meta["prompts"], open(f"{od}/prompts.json", "w"), indent=1)
        changed = True
    if not os.path.exists(f"{od}/actions.npy"):
        act = ed.get("actions")
        if not act and ed.get("base_roll"):
            act = f"{ed['map_dir']}/actions.npy" if ed.get("map_dir") else None
        if act and os.path.exists(act):
            shutil.copyfile(act, f"{od}/actions.npy")
            changed = True
    if "edit" not in meta:
        meta["edit"] = ed
        meta["files"] = {"video": "gen.mp4", "cond_ids": "ids.npz", "actions": "actions.npy (uint8 [20,5]: w a s d attack, "
                         "0.25 s blocks; cell j = block j-1, cell 0 = cell 1)", "prompts": "prompts.json (21 cell prompts)",
                         "first_frame": "first.png", "side_by_side": "side.mp4", "sheet": "sheet.jpg"}
        tmp = f"{od}/.meta.fin.tmp"
        json.dump(meta, open(tmp, "w"), ensure_ascii=False, indent=1)
        os.replace(tmp, mp)
        changed = True
    return changed


def cmd_finalize(a) -> None:
    """补齐结果目录 + 写总索引 $A/index.jsonl(每条一行:name、dir、type、variant、label、base / group、文件相对路径)。"""
    n = k = 0
    rows = []
    for root in a.roots:
        for od in sorted(glob.glob(f"{rp(root)}/*/")):
            od = od.rstrip("/")
            if os.path.exists(f"{od}/meta.json"):
                n += 1
                k += finalize_dir(od)
                m = json.load(open(f"{od}/meta.json"))
                ed = m.get("edit") or {}
                rows.append({"name": m["name"], "dir": os.path.relpath(od, A), "type": ed.get("type"),
                             "variant": ed.get("variant"), "label": ed.get("label"), "base": ed.get("base"),
                             "group": ed.get("group"), "source_clip": ed.get("source_clip"), "edit_frame": ed.get("edit_frame"),
                             "files": ["gen.mp4", "ids.npz", "actions.npy", "prompts.json", "first.png", "meta.json"]})
    with open(f"{A}/index.jsonl", "w") as fh:
        for r in rows:
            fh.write(json.dumps(r, ensure_ascii=False) + "\n")
    print(f"finalize:{n} 条完成的结果,补齐 {k} 条;索引 → {A}/index.jsonl")


# ------------------------------------------------------------------ compose ----
def _cases(names: list[str], root: str = f"{A}/roll") -> list[str]:
    return [f"{root}/{n}" for n in names if os.path.exists(f"{root}/{n}/meta.json")]


def sheet(paths: list[str], labels: list[str], out: str, frames=(0, 20, 40, 60, 80), tw: int = 312) -> None:
    """帧拼图:每行一条结果(标签 + 帧 0/20/40/60/80),jpg。"""
    import cv2
    th = round(tw * 480 / 832)
    rows = []
    for p, lab in zip(paths, labels):
        z = np.load(f"{p}/frames.npz")
        idx = list(z["idx"])
        tiles = [cv2.resize(z["rgb"][idx.index(f)], (tw, th), interpolation=cv2.INTER_AREA) for f in frames if f in idx]
        r = np.concatenate(tiles, 1).copy()
        for t, f in enumerate(frames):
            cv2.putText(r, f"f{f}", (t * tw + 4, th - 6), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (255, 255, 255), 1, cv2.LINE_AA)
        cv2.rectangle(r, (0, 0), (min(r.shape[1], 12 + 9 * len(lab)), 20), (0, 0, 0), -1)
        cv2.putText(r, lab, (4, 15), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)
        rows.append(r)
    os.makedirs(os.path.dirname(out), exist_ok=True)
    cv2.imwrite(out, cv2.cvtColor(np.concatenate(rows, 0), cv2.COLOR_RGB2BGR), [cv2.IMWRITE_JPEG_QUALITY, 88])


def cmd_compose(a) -> None:
    import edit_compose as EC
    EC.compose_app(a)


def main(argv=None) -> None:
    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
    sp = ap.add_subparsers(dest="cmd", required=True)
    sp.add_parser("plan")
    sp.add_parser("rolljobs")
    sp.add_parser("galleryplan")
    sp.add_parser("mirror")
    f = sp.add_parser("finalize")
    f.add_argument("--roots", nargs="*", default=[f"{A}/roll", f"{A}/sameworld/roll", f"{A}/long/roll"])
    c = sp.add_parser("compose")
    c.add_argument("--only", nargs="*", default=None, help="只出这些部分:look / act / all_look")
    a = ap.parse_args(argv)
    {"plan": cmd_plan, "rolljobs": cmd_rolljobs, "galleryplan": cmd_galleryplan, "mirror": cmd_mirror, "finalize": cmd_finalize,
     "compose": cmd_compose}[a.cmd](a)


if __name__ == "__main__":
    main()