@kolbo/mcp 1.112.1 → 1.112.4

package/skill/scripts/micro-drama/burn.py

@@ -0,0 +1,121 @@
+"""Burn captions (and an optional hook) into a finished cut with libass. Audio is copied untouched.
+
+usage:
+  python burn.py social <in.mp4> <words.srt> <out.mp4> [--hook "Line one|Line two"] [--hook-dy 0] [--font NAME] [--fontsdir DIR]
+  python burn.py film   <in.mp4> <words.srt> <out.mp4> [--font NAME] [--fontsdir DIR]
+
+words.srt = one-word-per-cue SRT from Kolbo transcribe_audio (word_by_word_srt_url) of THIS file, corrected
+against the script's words (keep the timings, fix only mishears).
+social: word-pop captions, max 3 words per line, the spoken word in yellow, each word one frame early, sitting
+        just above the bottom 35% platform UI band; hook = two lines in a white box for exactly 0-3 s, at the waist,
+        right above the captions. All text stays inside the centre 82% so the right-side buttons never cover it.
+film:   plain subtitles for the full episode page - max 4 words per row, 2 rows, low in frame, soft shadow.
+Also writes <out>.ass next to the output for inspection.
+"""
+import argparse
+import os
+import subprocess
+
+from media import probe, srt_words
+
+YELLOW, WHITE, BLACK = "&H003DE2FF", "&H00FFFFFF", "&H00000000"
+
+
+def ts(t):
+    t = max(t, 0)
+    return f"{int(t // 3600)}:{int(t % 3600 // 60):02d}:{t % 60:05.2f}"
+
+
+def lines_of(words, max_words, pause=0.6):
+    out, cur = [], []
+    for w in words:
+        if cur and (len(cur) >= max_words or w[1] - cur[-1][2] > pause or cur[-1][0][-1:] in ",.?!"):
+            out.append(cur)
+            cur = []
+        cur.append(w)
+    return out + ([cur] if cur else [])
+
+
+def build(mode, video, srt, hook, hook_dy, font):
+    info = probe(video)
+    W, H, frame = info["w"], info["h"], 1 / info["fps"]
+    margin = int(W * 0.09)
+    cap_y = int(H * 0.65) - int(H * 0.02)            # just above the bottom 35% UI band
+    words = srt_words(srt)
+    head = (f"[Script Info]\nScriptType: v4.00+\nPlayResX: {W}\nPlayResY: {H}\nWrapStyle: 2\n\n[V4+ Styles]\n"
+            "Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, "
+            "Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, "
+            "MarginR, MarginV, Encoding\n")
+    ev = "\n[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n"
+    if mode == "film":
+        size = int(W * 0.063)
+        head += (f"Style: Sub,{font},{size},{WHITE},{WHITE},{BLACK},&H80000000,0,0,0,0,100,100,0,0,1,1.5,2,2,"
+                 f"{margin},{margin},{int(H * 0.08)},1\n")
+        for ln in lines_of(words, 8):
+            text = " ".join(w[0] for w in ln)
+            parts = text.split()
+            if len(parts) > 4:
+                text = " ".join(parts[:len(parts) // 2 + len(parts) % 2]) + "\\N" + " ".join(parts[len(parts) // 2 + len(parts) % 2:])
+            ev += f"Dialogue: 0,{ts(ln[0][1] - frame)},{ts(ln[-1][2] + 0.2)},Sub,,0,0,0,,{text}\n"
+        return head + ev
+    cap = int(W * 0.07)
+    head += (f"Style: Cap,{font},{cap},{WHITE},{WHITE},{BLACK},&H00000000,1,0,0,0,100,100,0,0,1,{cap * 0.12:.1f},0,2,"
+             f"{margin},{margin},{H - cap_y},1\n")
+    head += (f"Style: Hook,{font},10,{BLACK},{BLACK},{BLACK},{BLACK},1,0,0,0,100,100,0,0,1,0,0,5,0,0,0,1\n"
+             f"Style: Box,{font},10,{WHITE},{WHITE},{WHITE},{WHITE},0,0,0,0,100,100,0,0,1,0,0,7,0,0,0,1\n")
+    caps = []
+    for ln in lines_of(words, 3):
+        for k, (w, a, b) in enumerate(ln):
+            end = ln[k + 1][1] if k + 1 < len(ln) else b + 0.15
+            text = " ".join(("{\\c" + YELLOW + "}" + x + "{\\c" + WHITE + "}") if j == k else x
+                            for j, (x, _, _) in enumerate(ln))
+            caps.append([a - frame, end - frame, text])
+    for k in range(len(caps) - 1):  # never two caption states on screen at once (libass stacks them)
+        caps[k][1] = max(min(caps[k][1], caps[k + 1][0]), caps[k][0] + frame)
+    for a, b, text in caps:
+        ev += f"Dialogue: 1,{ts(a)},{ts(b)},Cap,,0,0,0,,{text}\n"
+    if hook:
+        lines = hook.split("|")
+        # ponytail: box width estimated at 0.6 x font size per character (bold sans); measure with a font
+        # library if a hook font renders much wider.
+        size = min(W * 0.068, (W * 0.82 - W * 0.07) / (0.6 * max(len(x) for x in lines)))
+        pad, r = size * 0.5, size * 0.45
+        bw = 0.6 * size * max(len(x) for x in lines) + 2 * pad
+        bh = size * 1.2 * len(lines) + 2 * pad
+        bottom = cap_y - cap * 1.3 - hook_dy           # sits right above the caption line
+        x0, y0 = (W - bw) / 2, bottom - bh
+        path = (f"m {r:.0f} 0 l {bw - r:.0f} 0 b {bw - .45 * r:.0f} 0 {bw:.0f} {.45 * r:.0f} {bw:.0f} {r:.0f} "
+                f"l {bw:.0f} {bh - r:.0f} b {bw:.0f} {bh - .45 * r:.0f} {bw - .45 * r:.0f} {bh:.0f} {bw - r:.0f} {bh:.0f} "
+                f"l {r:.0f} {bh:.0f} b {.45 * r:.0f} {bh:.0f} 0 {bh - .45 * r:.0f} 0 {bh - r:.0f} "
+                f"l 0 {r:.0f} b 0 {.45 * r:.0f} {.45 * r:.0f} 0 {r:.0f} 0")
+        ev += f"Dialogue: 2,{ts(0)},{ts(3.0)},Box,,0,0,0,,{{\\an7\\pos({x0:.0f},{y0:.0f})\\p1}}{path}{{\\p0}}\n"
+        ev += (f"Dialogue: 3,{ts(0)},{ts(3.0)},Hook,,0,0,0,,{{\\an5\\pos({W / 2:.0f},{y0 + bh / 2:.0f})\\fs{size:.0f}}}"
+               + "\\N".join(lines) + "\n")
+    return head + ev
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("mode", choices=["social", "film"])
+    p.add_argument("video")
+    p.add_argument("srt")
+    p.add_argument("out")
+    p.add_argument("--hook", default="")
+    p.add_argument("--hook-dy", type=int, default=0, help="move the hook down by N pixels if it covers a face or body")
+    p.add_argument("--font", default="Montserrat ExtraBold")
+    p.add_argument("--fontsdir", default="")
+    a = p.parse_args()
+    ass = os.path.abspath(a.out) + ".ass"
+    open(ass, "w", encoding="utf-8").write(build(a.mode, a.video, a.srt, a.hook, a.hook_dy, a.font))
+    # libass path escaping is fragile on Windows: run from the .ass folder with a bare file name.
+    flt = f"subtitles={os.path.basename(ass)}" + (f":fontsdir={a.fontsdir}" if a.fontsdir else "")
+    tmp = os.path.abspath(a.out) + ".part.mp4"
+    subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", os.path.abspath(a.video), "-vf", flt, "-c:v", "libx264",
+                    "-crf", "16", "-preset", "medium", "-pix_fmt", "yuv420p", "-c:a", "copy", "-movflags", "+faststart",
+                    tmp], check=True, cwd=os.path.dirname(ass))
+    os.replace(tmp, os.path.abspath(a.out))
+    print("->", a.out)
+
+
+if __name__ == "__main__":
+    main()

package/skill/scripts/micro-drama/cut.py

@@ -0,0 +1,107 @@
+"""Build the tight cut from final clips with exact frames, L/J-cuts and smooth sound seams. Levels never change.
+
+usage: python cut.py <cut.json>
+cut.json:
+{
+  "out": "final/ep01-tight.mp4",
+  "xfade": 0.3,
+  "segments": [
+    {"file": "final/ep01-part1.mp4", "start": 0.0, "end": 9.4},
+    {"file": "final/ep01-part1.mp4", "start": 11.2, "end": 14.0, "lcut": 0.3},
+    {"file": "final/ep01-part2.mp4", "start": 0.2, "end": 6.1, "zoom": 1.5, "y": 0.2, "flip": false, "jcut": 0}
+  ]
+}
+- start/end: seconds on that file. In/out points within 0.15 s of a shot change are moved 1.5 frames inside the
+  shot, so no frame of the neighbouring shot flashes in.
+- lcut: this shot's PICTURE comes in that many seconds early over the end of the previous line (L-cut).
+- jcut: this shot's SOUND starts that many seconds early under the previous picture (J-cut).
+- zoom/y: punch-in (1.5 = 150%) anchored at y (0 top, 0.5 centre) for a jump inside one shot.
+- flip: horizontal mirror to fix a 180-degree break. Check every one-sided detail (scar, parting, ring, text) first.
+- Seams borrow `xfade` s of the incoming shot's own sound and crossfade it, so room tone never jumps.
+  Contiguous segments of the same file butt-join with no borrow.
+"""
+import bisect
+import json
+import os
+import subprocess
+import sys
+
+from media import frame_pts, probe, shot_changes
+
+
+def snap(s, e, changes, fps):
+    for c in changes:
+        if abs(e - c) < 0.15:
+            e = c - 1.5 / fps
+        if abs(s - c) < 0.15:
+            s = c + 1.5 / fps
+    return s, e
+
+
+def main(spec_path):
+    spec = json.load(open(spec_path, encoding="utf-8"))
+    base = os.path.dirname(os.path.abspath(spec_path))
+    path = lambda x: x if os.path.isabs(x) else os.path.join(base, x)
+    X = spec.get("xfade", 0.3)
+    cache, segs = {}, []
+    for raw in spec["segments"]:
+        f = path(raw["file"])
+        if f not in cache:
+            info = probe(f)
+            cache[f] = (info, shot_changes(f), frame_pts(f))
+        info, changes, pts = cache[f]
+        fps = info["fps"]
+        s, e = snap(raw["start"], raw["end"], changes, fps)
+        contiguous = bool(segs) and segs[-1]["file"] == f and abs(segs[-1]["raw_end"] - raw["start"]) < 1e-6
+        if contiguous:  # one shared cut point, mid-frame, so no word repeats
+            c = min(changes, key=lambda c: abs(c - raw["start"]), default=raw["start"])
+            s = c - 0.5 / fps if abs(c - raw["start"]) < 0.15 else raw["start"]
+            segs[-1]["end"] = s
+        # Snap to real frame times so audio length == frame count (lip sync never drifts).
+        k = bisect.bisect_left(pts, s - 1e-4)
+        s = pts[min(k, len(pts) - 1)]
+        k = bisect.bisect_left(pts, e - 1e-4)
+        e = pts[max(k - 1, 0)] + 1 / fps
+        segs.append({"file": f, "start": s, "end": e, "raw_end": raw["end"], "fps": fps, "w": info["w"], "h": info["h"],
+                     "zoom": raw.get("zoom", 1), "y": raw.get("y", 0.5), "flip": raw.get("flip", False),
+                     "lcut": round(raw.get("lcut", 0) * fps) / fps, "jcut": round(raw.get("jcut", 0) * fps) / fps,
+                     "contiguous": contiguous})
+    ins, fc, vl = [], "", ""
+    for i, sg in enumerate(segs):
+        nxt = segs[i + 1] if i + 1 < len(segs) else {"lcut": 0, "jcut": 0}
+        ins += ["-i", sg["file"]]
+        z = sg["zoom"]
+        crop = (f",crop=iw/{z}:ih/{z}:(iw-iw/{z})/2:(ih-ih/{z})*{sg['y']},scale={sg['w']}:{sg['h']}:flags=lanczos"
+                if z != 1 else "")
+        fc += (f"[{i}:v]trim={sg['start'] - 0.002}:{sg['end'] - nxt['lcut'] - 0.002},setpts=PTS-STARTPTS{crop}"
+               f"{',hflip' if sg['flip'] else ''},setsar=1[v{i}];")
+        a0 = sg["start"] + sg["lcut"] - sg["jcut"] - (X if i and not sg["contiguous"] else 0)
+        if a0 < 0:
+            sys.exit(f"segment {i} needs {X + sg['jcut']:.2f}s of sound before its in-point; start it later")
+        fc += f"[{i}:a]atrim={a0}:{sg['end'] - nxt['jcut']},asetpts=PTS-STARTPTS[a{i}];"
+        vl += f"[v{i}]"
+    fc += f"{vl}concat=n={len(segs)}:v=1:a=0[v];"
+    prev = "a0"
+    for i in range(1, len(segs)):
+        join = "concat=n=2:v=0:a=1" if segs[i]["contiguous"] else f"acrossfade=d={X}:c1=tri:c2=tri"
+        fc += f"[{prev}][a{i}]{join}[x{i}];"
+        prev = f"x{i}"
+    out = path(spec["out"])
+    os.makedirs(os.path.dirname(out) or ".", exist_ok=True)
+    tmp = out + ".part.mp4"
+    subprocess.run(["ffmpeg", "-v", "error", "-y", *ins, "-filter_complex", fc.rstrip(";"), "-map", "[v]",
+                    "-map", f"[{prev}]", "-c:v", "libx264", "-crf", "16", "-preset", "medium", "-pix_fmt", "yuv420p",
+                    "-c:a", "aac", "-b:a", "256k", "-movflags", "+faststart", tmp], check=True)
+    os.replace(tmp, out)
+    t = 0.0
+    for i, sg in enumerate(segs):
+        nxt = segs[i + 1]["lcut"] if i + 1 < len(segs) else 0
+        print(f"{t:7.2f}  {os.path.basename(sg['file'])} {sg['start']:.3f}-{sg['end'] - nxt:.3f}"
+              + (f" zoom {sg['zoom']}" if sg["zoom"] != 1 else "") + (" flip" if sg["flip"] else "")
+              + (f" L {sg['lcut']:.2f}" if sg["lcut"] else "") + (f" J {sg['jcut']:.2f}" if sg["jcut"] else ""))
+        t += sg["end"] - nxt - sg["start"]
+    print(f"total {t:.2f}s -> {out}")
+
+
+if __name__ == "__main__":
+    main(sys.argv[1])

package/skill/scripts/micro-drama/flash_check.py

@@ -0,0 +1,20 @@
+"""Find one-frame flashes and too-short shots in a cut. Exit code 1 if anything is found.
+usage: python flash_check.py <video> [min_shot_s=1.2]"""
+import sys
+
+import numpy as np
+
+from media import frame_diffs, probe
+
+video = sys.argv[1]
+min_shot = float(sys.argv[2]) if len(sys.argv) > 2 else 1.2
+fps = probe(video)["fps"]
+d = frame_diffs(video, fps)
+cuts = [int(i) for i in np.where(d > 18)[0] if i > 0]
+bad = 0
+for a, b in zip(cuts, cuts[1:]):
+    if (b - a) / fps < min_shot:
+        print(f"short shot {a / fps:.3f}-{b / fps:.3f}s ({b - a} frames)")
+        bad += 1
+print(f"{len(cuts)} cuts checked, {bad} problems")
+sys.exit(1 if bad else 0)

package/skill/scripts/micro-drama/media.py

@@ -0,0 +1,54 @@
+"""Shared ffmpeg helpers for the micro-drama edit scripts. Needs ffmpeg/ffprobe on PATH and numpy."""
+import json
+import subprocess
+
+import numpy as np
+
+
+def probe(video):
+    out = subprocess.check_output(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
+                                   "stream=width,height,avg_frame_rate:format=duration", "-of", "json", video])
+    d = json.loads(out)
+    s = d["streams"][0]
+    num, den = s["avg_frame_rate"].split("/")
+    return {"w": s["width"], "h": s["height"], "fps": float(num) / float(den or 1),
+            "duration": float(d["format"]["duration"])}
+
+
+def frame_pts(video):
+    """Real presentation time of every video frame, sorted."""
+    out = subprocess.check_output(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
+                                   "packet=pts_time", "-of", "csv=p=0", video], text=True)
+    return sorted(float(x) for x in out.split() if x and x != "N/A")
+
+
+def gray_frames(video, fps):
+    raw = subprocess.check_output(["ffmpeg", "-v", "error", "-i", video, "-vf",
+                                   f"fps={fps},scale=90:160,format=gray", "-f", "rawvideo", "-"])
+    return np.frombuffer(raw, np.uint8).reshape(-1, 160, 90).astype(np.int16)
+
+
+def frame_diffs(video, fps):
+    f = gray_frames(video, fps)
+    return np.concatenate([[0], np.abs(np.diff(f, axis=0)).mean(axis=(1, 2))])
+
+
+def shot_changes(video, threshold=18):
+    """Time of the first frame of every new shot (hard cuts only)."""
+    fps = probe(video)["fps"]
+    d = frame_diffs(video, fps)
+    return [round(i / fps, 4) for i in np.where(d > threshold)[0] if i > 0]
+
+
+def srt_words(path):
+    """[(word, start, end)] from a one-word-per-cue SRT (Kolbo transcribe_audio word_by_word_srt_url)."""
+    def sec(t):
+        h, m, s = t.replace(",", ".").split(":")
+        return int(h) * 3600 + int(m) * 60 + float(s)
+    words = []
+    for block in open(path, encoding="utf-8").read().strip().split("\n\n"):
+        lines = block.strip().splitlines()
+        if len(lines) >= 3 and "-->" in lines[1]:
+            a, b = (x.strip() for x in lines[1].split("-->"))
+            words.append((" ".join(lines[2:]).strip(), sec(a), sec(b)))
+    return words

package/skill/scripts/micro-drama/pace_report.py

@@ -0,0 +1,76 @@
+"""Pace report: find dead air (no speech, little motion) in a joined episode. Candidates only - a human or the
+agent judges each one against the script beat (keep a look that lands, cut a stare that re-establishes nothing).
+
+usage: python pace_report.py <joined.mp4> <words.srt> [out.json]
+words.srt = one-word-per-cue SRT from Kolbo transcribe_audio (word_by_word_srt_url).
+Writes proposed keep-segments [[start, end], ...]; a piece whose removed gap has no real shot change gets
+[start, end, 1.5, 0.2] (1.5x punch-in so the jump reads as a new angle).
+"""
+import json
+import sys
+
+import numpy as np
+
+from media import frame_diffs, probe, shot_changes, srt_words
+
+STEP = 1 / 8      # analysis resolution (s)
+MAX_DEAD = 0.6    # dead air longer than this is a trim candidate
+LEAD_IN = 0.25    # keep before a line
+HOLD = 0.45       # keep after a line (the reaction beat)
+MIN_PIECE = 0.5
+
+
+def main(video, srt, out=None):
+    dur = probe(video)["duration"]
+    n = int(dur / STEP)
+    t = np.arange(n) * STEP
+    m = frame_diffs(video, 1 / STEP)[:n]
+    m = np.pad(m, (0, n - len(m)))
+    shots = shot_changes(video)
+    for c in shots:  # a hard cut is a spike, not action
+        m[max(int(c / STEP) - 1, 0):int(c / STEP) + 2] = 0
+    on = max(4.0, float(np.percentile(m, 70)))
+    keep = np.zeros(n, bool)
+    for _, a, b in srt_words(srt):
+        keep[(t >= a - LEAD_IN) & (t < b + HOLD)] = True
+    keep |= np.convolve(m > on, np.ones(4), "same") > 0
+    keep[t < 0.5] = True          # hook frame
+    keep[t > dur - 1.0] = True    # cliff hold
+    i = 0
+    while i < n:                  # short gaps are breath, keep them
+        if keep[i]:
+            i += 1
+            continue
+        j = i
+        while j < n and not keep[j]:
+            j += 1
+        if (j - i) * STEP <= MAX_DEAD:
+            keep[i:j] = True
+        i = j
+    segs, i = [], 0
+    while i < n:
+        if not keep[i]:
+            i += 1
+            continue
+        j = i
+        while j < n and keep[j]:
+            j += 1
+        s, e = round(float(t[i]), 3), round(min(float(t[j - 1]) + STEP, dur), 3)
+        if e - s >= MIN_PIECE:
+            segs.append([s, e])
+        i = j
+    for k in range(1, len(segs)):
+        a, b = segs[k - 1][1], segs[k][0]
+        if not any(a - 0.1 <= c <= b + 0.1 for c in shots) and len(segs[k - 1]) == 2:
+            segs[k] += [1.5, 0.2]
+    new = sum(s[1] - s[0] for s in segs)
+    print(f"{video}: {dur:.1f}s -> {new:.1f}s ({len(segs) - 1} trim candidates)")
+    for k in range(1, len(segs)):
+        a, b = segs[k - 1][1], segs[k][0]
+        print(f"  trim {a:6.2f}-{b:6.2f} ({b - a:.2f}s){'  + 1.5x punch-in' if len(segs[k]) > 2 else ''}")
+    if out:
+        json.dump(segs, open(out, "w"), indent=1)
+
+
+if __name__ == "__main__":
+    main(*sys.argv[1:4])

package/skill/scripts/micro-drama/shot_map.py

@@ -0,0 +1,38 @@
+"""Shot map: list every shot of a joined episode and save one contact sheet (first / middle / last frame per shot).
+
+usage: python shot_map.py <joined.mp4> <out_dir>
+Writes <out_dir>/shots.json ([{n, start, end}]) and <out_dir>/shot-NN.jpg strips. Look at every strip and note,
+per shot: who is frame-left / frame-right, where each person looks, shot size. That is the shot map the cut uses.
+"""
+import json
+import os
+import subprocess
+import sys
+from concurrent.futures import ThreadPoolExecutor
+
+from media import probe, shot_changes
+
+
+def main(video, out_dir):
+    os.makedirs(out_dir, exist_ok=True)
+    info = probe(video)
+    edges = [0.0] + shot_changes(video) + [info["duration"]]
+    shots = [{"n": i + 1, "start": round(a, 3), "end": round(b, 3)} for i, (a, b) in enumerate(zip(edges, edges[1:]))]
+
+    def strip(s):
+        a, b = s["start"], s["end"]
+        times = [a + 0.05, (a + b) / 2, max(b - 0.08, a + 0.05)]
+        inputs = sum((["-ss", f"{t:.3f}", "-i", video] for t in times), [])
+        subprocess.run(["ffmpeg", "-v", "error", "-y", *inputs, "-filter_complex",
+                        "".join(f"[{i}:v]scale=270:-2,trim=end_frame=1[s{i}];" for i in range(3)) + "[s0][s1][s2]hstack=3",
+                        "-frames:v", "1", os.path.join(out_dir, f"shot-{s['n']:02d}.jpg")], check=True)
+
+    with ThreadPoolExecutor(os.cpu_count()) as pool:
+        list(pool.map(strip, shots))
+    json.dump(shots, open(os.path.join(out_dir, "shots.json"), "w"), indent=1)
+    for s in shots:
+        print(f"shot {s['n']:2d}  {s['start']:7.2f}-{s['end']:7.2f}  ({s['end'] - s['start']:.2f}s)")
+
+
+if __name__ == "__main__":
+    main(*sys.argv[1:3])

package/src/apps/theme.js

@@ -152,7 +152,16 @@ body {
   align-items: center; justify-content: center; font-family: inherit;
 }
 .k-chip img.k-voice-thumb { width: 18px; height: 18px; border-radius: 999px; margin-left: -3px; }
-.k-ref-thumb { width: 26px; height: 26px; border-radius: 6px; object-fit: cover; border: 1px solid var(--border-strong); }
+.k-ref-thumb { width: 26px; height: 26px; border-radius: 6px; object-fit: cover; border: 1px solid var(--border-strong); }
+.k-input-section { flex-basis: 100%; min-width: 0; margin-top: 6px; }
+.k-input-label { display: block; color: var(--muted); font-size: 11px; margin-bottom: 6px; }
+.k-input-media { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; }
+.k-input-media .k-ref-thumb { width: 80px; height: 80px; object-fit: contain; background: var(--panel); }
+.k-ref-audio { display: flex; flex-direction: column; gap: 6px; max-width: 100%; font-size: 11px; }
+.k-ref-audio audio { width: 240px; max-width: 100%; height: 32px; }
+.k-template { display: flex; align-items: center; gap: 12px; font-size: 12px; }
+.k-template-thumb, .k-template-placeholder { width: 104px; height: 80px; border-radius: 8px; object-fit: contain; background: var(--panel); border: 1px solid var(--border-strong); }
+.k-template-placeholder { display: flex; align-items: center; justify-content: center; color: var(--muted); }
 .k-peek-hit { cursor: zoom-in; }
 .k-peek {
   position: absolute; inset: 0; z-index: 20;

package/src/apps/widgets/generation.js

@@ -385,7 +385,7 @@ function renderChips(sc) {
   if (s.mode) h += chip(esc(editLabel(s.mode)));
   if (Array.isArray(s.details)) s.details.forEach(function (d) { if (d) h += chip(esc(String(d))); });
   if (many && !kind) h += chip(sc.count + ' items');
-  h += referenceHTML(sc);
+  h += templateHTML(sc) + referenceHTML(sc);
   el('chips').innerHTML = h;
 }
 
@@ -429,7 +429,7 @@ function referenceHTML(sc) {
       h += '<video class="k-ref-thumb k-peek-hit" src="' + url + '#t=0.1" muted playsinline preload="metadata" title="'
         + title + '"' + peek + ' onerror="this.style.display=\\'none\\'"></video>';
     } else if (refs[i].kind === 'audio') {
-      h += '<span class="k-chip" title="' + title + '">' + ICONS.sound + ' audio ref</span>';
+      h += '<span class="k-ref-audio" title="' + title + '">' + ICONS.sound + ' audio ref<audio controls preload="none" src="' + url + '"></audio></span>';
     } else {
       h += '<img class="k-ref-thumb k-peek-hit" src="' + url + '" alt="" loading="lazy" title="' + title + '"'
         + peek + ' onerror="this.style.display=\\'none\\'">';
@@ -438,12 +438,23 @@ function referenceHTML(sc) {
   // Local files the caller passed by path: the iframe cannot load them and they
   // are only uploaded during the run, so name them instead of showing nothing.
   // The finished card carries the uploaded thumbnails and drops these.
-  if (sc.phase !== 'completed' && Array.isArray(sc.local_references)) {
-    sc.local_references.slice(0, 6).forEach(function (name) {
+  if (sc.phase !== 'completed' && Array.isArray(sc.local_references) && !refs.length) {
+    sc.local_references.forEach(function (name) {
       h += '<span class="k-chip" title="' + esc(name) + '">' + ICONS.image + ' ' + esc(String(name).slice(0, 24)) + '</span>';
     });
   }
-  return h;
+  return h ? '<div class="k-input-section"><span class="k-input-label">References</span><div class="k-input-media">' + h + '</div></div>' : '';
+}
+function templateHTML(sc) {
+  var s = sc.settings || {};
+  if (!s.preset_id && !s.preset_name && !s.preset_thumbnail) return '';
+  var name = s.preset_name || 'Selected template';
+  var url = s.preset_thumbnail;
+  var media = url ? '<img class="k-template-thumb k-peek-hit" src="' + esc(url) + '" alt="' + esc(name)
+    + '" loading="lazy" data-peek="' + esc(url) + '" data-peek-kind="image" data-peek-cap="' + esc(name) + '">'
+    : '<span class="k-template-placeholder">' + ICONS.image + '</span>';
+  return '<div class="k-input-section"><span class="k-input-label">Template</span><div class="k-template">'
+    + media + '<span>' + esc(name) + '</span></div></div>';
 }
 // Which characters/looks are locked into this generation — by face and name,
 // resolved from visual_dna_ids server-side. "1 Visual DNA" told the user nothing
@@ -830,6 +841,7 @@ function poll(sc) {
 
       var done = Object.assign({}, sc, r, {
         phase: 'completed',
+        settings: Object.assign({}, sc.settings || {}, r.settings || {}),
         urls: r.urls || st.urls || [],
         credits_used: st.credits_used != null ? st.credits_used : sc.credits_used,
         // Status structuredContent used to set open_url:undefined and wipe the
@@ -1462,7 +1474,7 @@ function kindFromTool(tool, sc) {
 function liveFromTimedOut(sc) {
   if (!sc || !sc.generation_id || isTerminal(sc.state) || Array.isArray(sc.urls)) return null;
   var ids = Array.isArray(sc.generation_ids) && sc.generation_ids.length > 1 ? sc.generation_ids : null;
-  var live = {
+  var live = Object.assign({}, preRefSc(originTool, originArgs), {
     widget: 'generation',
     phase: 'generating',
     tool: originTool,
@@ -1477,7 +1489,8 @@ function liveFromTimedOut(sc) {
       quality: originArgs.quality,
       mode: originArgs.operation,
       visual_dna_ids: originArgs.visual_dna_ids,
-      moodboard_id: originArgs.moodboard_id
+      moodboard_id: originArgs.moodboard_id,
+      preset_id: originArgs.preset_id
     }, originArgs),
     count: ids ? ids.length : (originArgs.num_images || 1),
     generation_id: sc.generation_id,
@@ -1485,14 +1498,14 @@ function liveFromTimedOut(sc) {
     status_args: ids ? { generation_ids: ids, wait: true } : { generation_id: sc.generation_id, wait: true },
     session_id: sc.session_id || originArgs.session_id,
     project_id: sc.project_id || originArgs.project_id
-  };
+  });
   if (ids) { live.generation_ids = ids; live.prompts = originArgs.prompts || []; }
   return live;
 }
 
 function completedFromPlain(sc) {
   if (!sc || (!Array.isArray(sc.urls) && !Array.isArray(sc.scenes))) return null;
-  return Object.assign({}, sc, {
+  return Object.assign({}, preRefSc(originTool, originArgs), sc, {
     widget: 'generation',
     phase: 'completed',
     tool: originTool,
@@ -1505,7 +1518,8 @@ function completedFromPlain(sc) {
       resolution: originArgs.draft === true ? '480p-draft' : originArgs.draft === false ? String(originArgs.resolution || '').replace(/-draft$/i, '') : originArgs.resolution,
       aspect_ratio: originArgs.aspect_ratio,
       quality: originArgs.quality,
-      mode: originArgs.operation
+      mode: originArgs.operation,
+      preset_id: originArgs.preset_id
     }, originArgs),
     urls: sc.urls || [],
     session_id: sc.session_id || originArgs.session_id,

package/src/tools/generate.js

@@ -110,7 +110,7 @@ async function submitBatch(rawItems, submitOne) {
 // multi-id branch, same fix: always ship structuredContent via the shared
 // kind:'status' grid, which already renders any mix of completed/processing
 // items correctly.
-async function pollBatch(client, batch, { interval, timeout }, toolName, submittedModel) {
+async function pollBatch(client, batch, { interval, timeout }, toolName, submittedModel, inputs = {}) {
   const polls = await Promise.all(batch.ids.map((id) => pollOrTimedOut(client, id, { interval, timeout })));
   const generations = polls.map((p, i) => p.timedOut
     ? { prompt: batch.ok[i].prompt, generation_id: batch.ids[i], status: 'processing', note: 'Still running — call get_generation_status with wait=true to collect it.' }
@@ -126,8 +126,9 @@ async function pollBatch(client, batch, { interval, timeout }, toolName, submitt
   return uiCompleted({
     tool: toolName, kind: 'status', client,
     model: modelsRan.length === 1 ? modelsRan[0] : (submittedModel || 'Generations'),
-    gen: { generation_id: batch.ids[0], session_id: batch.ok[0].gen.session_id },
-    settings: {},
+    gen: { generation_id: batch.ids[0], session_id: batch.ok[0].gen.session_id },
+    settings: {},
+    ...inputs,
     items: generations.map(g => ({
       id: g.generation_id,
       state: g.status,
@@ -338,10 +339,11 @@ function registerGenerateTools(server, client, options = {}) {
       if (!prompt && !(prompts && prompts.length)) throw new Error('Provide prompt or prompts');
       model = await canonicalModelId(client, model, 'text_to_img'); // lenient id resolution ("z-image" → "z-image/turbo")
       aspect_ratio = await resolveCatalogAspectRatio(client, model, aspect_ratio, 'text_to_img');
-      const shared = {
-        model, aspect_ratio, enhance_prompt, font_ids,
-        reference_images, visual_dna_ids, moodboard_id, enable_web_search, resolution, quality, background, output_format, output_compression, moderation, mask_image_url, preset_id, cinematic, skip_color_palette, project_id, session_id
-      };
+      const shared = await rehostLocalPaths(client, {
+        model, aspect_ratio, enhance_prompt, font_ids,
+        reference_images, visual_dna_ids, moodboard_id, enable_web_search, resolution, quality, background, output_format, output_compression, moderation, mask_image_url, preset_id, cinematic, skip_color_palette, project_id, session_id
+      }, { allowLocalFiles: !options.remote });
+      reference_images = [...(shared.reference_images || []), shared.mask_image_url].filter(Boolean);
 
       // Batch mode: N different prompts, one widget owning all generation ids.
       if (prompts && prompts.length) {
@@ -354,7 +356,7 @@ function registerGenerateTools(server, client, options = {}) {
           status_args: { generation_ids: batch.ids, wait: true },
           reference_images
         });
-        return pollBatch(client, batch, { interval: (batch.ok[0].gen.poll_interval_hint || 3) * 1000, timeout: 150000 }, 'generate_image', model);
+        return pollBatch(client, batch, { interval: (batch.ok[0].gen.poll_interval_hint || 3) * 1000, timeout: 150000 }, 'generate_image', model, { settings: imageSettings(shared), reference_images });
       }
 
       const gen = await client.post('/v1/generate/image', { ...shared, prompt, num_images });
@@ -429,10 +431,12 @@ function registerGenerateTools(server, client, options = {}) {
       if (!prompt && !(prompts && prompts.length)) throw new Error('Provide prompt or prompts');
       model = await canonicalModelId(client, model, 'image_editing'); // lenient id resolution ("z-image" → "z-image/turbo")
       aspect_ratio = await resolveCatalogAspectRatio(client, model, aspect_ratio, 'image_editing');
-      const shared = {
-        model, source_images, reference_images, aspect_ratio, enhance_prompt, font_ids,
-        visual_dna_ids, moodboard_id, enable_web_search, resolution, quality, background, output_format, output_compression, moderation, mask_image_url, preset_id, cinematic, skip_color_palette, project_id, session_id
-      };
+      const shared = await rehostLocalPaths(client, {
+        model, source_images, reference_images, aspect_ratio, enhance_prompt, font_ids,
+        visual_dna_ids, moodboard_id, enable_web_search, resolution, quality, background, output_format, output_compression, moderation, mask_image_url, preset_id, cinematic, skip_color_palette, project_id, session_id
+      }, { allowLocalFiles: !options.remote });
+      source_images = shared.source_images;
+      reference_images = [...(shared.reference_images || []), shared.mask_image_url].filter(Boolean);
       const settings = imageSettings(shared);
 
       // Batch mode: N different edit instructions against the SAME source
@@ -449,7 +453,7 @@ function registerGenerateTools(server, client, options = {}) {
           status_args: { generation_ids: batch.ids, wait: true },
           reference_images: [...(source_images || []), ...(reference_images || [])]
         });
-        return pollBatch(client, batch, { interval: (batch.ok[0].gen.poll_interval_hint || 3) * 1000, timeout: 150000 }, 'generate_image_edit', model);
+        return pollBatch(client, batch, { interval: (batch.ok[0].gen.poll_interval_hint || 3) * 1000, timeout: 150000 }, 'generate_image_edit', model, { settings, reference_images: [...(source_images || []), ...reference_images] });
       }
 
       const gen = await client.post('/v1/generate/image-edit', { ...shared, prompt, num_images });
@@ -1441,7 +1445,14 @@ function registerGenerateTools(server, client, options = {}) {
           // the live card merges this payload over its submit-time state, so
           // the finished card shows every reference, including server-side
           // additions (DNA stills, merged sources) the tool call never named.
-          reference_images: res.reference_images,
+          reference_images: res.reference_images,
+          reference_videos: res.reference_videos,
+          reference_audio: res.reference_audio,
+          ...(res.preset ? { settings: {
+            preset_id: res.preset.id,
+            preset_name: res.preset.name,
+            preset_thumbnail: res.preset.thumbnail_url,
+          } } : {}),
           // Transcription results ride the same status tool as media
           // generations; without these the transcript widget merges a payload
           // with no transcript in it.