kasaframe 0.0.0-stage → 0.1.3

package/packages/patterns/src/trend/draw.ts

@@ -0,0 +1,140 @@
+import { applyStyle, clamp } from "@kasaframe/core";
+import { fitSize } from "@kasaframe/motion/moves";
+import { partial } from "@kasaframe/themes/slotkit";
+import { ACCENT_TEXT, area, decimalsOf, fmt, moving, node, slotsOf } from "../kit.ts";
+import type { Pattern } from "../types.ts";
+
+export interface TrendContent {
+  points: { x: string; y: number }[];
+  unit?: string;
+  mark?: { x: string; label: string };
+}
+
+const SVG = "http://www.w3.org/2000/svg";
+
+/**
+ * 변화 — 선이 고른 빠르기로 그어지며 아래 면이 같이 찬다. 머리의 읽음값은 지나친 점의 값만 찍는다(점 사이 지어낸 값 없음).
+ * 짚을 점(mark)에 닿으면 세로 줄과 딱지가 서고, 끝 점에 닿으면 끝 값이 크게 앉는다.
+ */
+const pattern: Pattern<TrendContent> = {
+  id: "trend.draw",
+  type: "trend",
+  does: "선이 그어지며 아래 면이 차고, 머리 읽음값이 지나친 점의 값을 찍고, 짚을 점에 줄과 딱지가 선다",
+  energy: ["mid"],
+  family: "draw",
+  camera: ["none"],
+  bg: "stage",
+  aspects: ["16:9", "9:16", "1:1"],
+  dur: { min: 2.6, max: 9 },
+  themes: { "og-measure": 0.5, "debug-hud": 0.5 },
+  fits(c) {
+    const pts = c?.points;
+    if (!Array.isArray(pts) || pts.length < 3) return "points 가 셋보다 적다";
+    if (pts.length > 24) return "points 가 스물넷을 넘는다";
+    for (const [i, p] of pts.entries()) if (!Number.isFinite(p?.y) || typeof p.x !== "string") return `points[${i}] 가 {x: 글, y: 수} 가 아니다`;
+    if (c.mark && !pts.some((p) => p.x === c.mark!.x)) return `mark.x "${c.mark.x}" 가 points 에 없다`;
+    return true;
+  },
+  build(root, ctx, c, kit) {
+    const slots = slotsOf(kit);
+    const { w, h, vertical, u } = area(ctx, kit);
+    const pts = c.points;
+    const n = pts.length;
+    const unit = c.unit ?? "";
+    const dec = Math.max(...pts.map((p) => decimalsOf(p.y)));
+    const lo = Math.min(0, ...pts.map((p) => p.y));
+    const hi = Math.max(...pts.map((p) => p.y));
+    const last = `${fmt(pts[n - 1].y, dec)}${unit ? ` ${unit}` : ""}`;
+    const bigPx = fitSize(last, w * 0.5, h, { hShare: vertical ? 0.1 : 0.16, max: Math.round(200 * u), min: Math.round(56 * u) });
+    const axisPx = Math.round(Math.max(28 * u, bigPx * 0.26));
+
+    const cx = w * 0.04;
+    const cw = w * 0.92;
+    const ctop = bigPx * 1.5;
+    const ch = h * 0.94 - ctop - axisPx * 1.8;
+    const xy = pts.map((p, i): [number, number] => [cx + (cw * i) / (n - 1), ctop + ch * (1 - (p.y - lo) / (hi - lo || 1))]);
+
+    const host = node(root, "position:absolute;inset:0");
+    const big = node(host, `position:absolute;right:${w * 0.04}px;top:0;font-family:var(--kf-font-display);font-size:${bigPx}px;font-weight:${ctx.style.type?.weightDisplay ?? 800};color:${ACCENT_TEXT};line-height:1.1;white-space:nowrap;font-variant-numeric:tabular-nums`);
+    kit.stage?.hero(big);
+    const svg = host.ownerDocument.createElementNS(SVG, "svg");
+    svg.setAttribute("style", "position:absolute;inset:0;width:100%;height:100%;overflow:visible");
+    host.append(svg);
+    const base = host.ownerDocument.createElementNS(SVG, "line");
+    for (const [k, v] of Object.entries({ x1: cx, y1: ctop + ch, x2: cx + cw, y2: ctop + ch })) base.setAttribute(k, String(v));
+    base.setAttribute("stroke", "var(--kf-line)");
+    base.setAttribute("stroke-width", String(Math.max(2, Math.round(3 * u))));
+    const fillPoly = host.ownerDocument.createElementNS(SVG, "polygon");
+    fillPoly.setAttribute("fill", "var(--kf-accent)");
+    fillPoly.setAttribute("opacity", "0.28");
+    const linePoly = host.ownerDocument.createElementNS(SVG, "polyline");
+    linePoly.setAttribute("fill", "none");
+    linePoly.setAttribute("stroke", "var(--kf-accent)");
+    linePoly.setAttribute("stroke-width", String(Math.round(10 * u)));
+    linePoly.setAttribute("stroke-linejoin", "round");
+    linePoly.setAttribute("stroke-linecap", "round");
+    svg.append(base, fillPoly, linePoly);
+    const dotR = Math.round(12 * u);
+    const dots = xy.map(([x, y]) => {
+      const d = host.ownerDocument.createElementNS(SVG, "circle");
+      d.setAttribute("cx", String(x));
+      d.setAttribute("cy", String(y));
+      d.setAttribute("r", String(dotR));
+      d.setAttribute("fill", "var(--kf-bg)");
+      d.setAttribute("stroke", "var(--kf-accent)");
+      d.setAttribute("stroke-width", String(Math.round(5 * u)));
+      d.setAttribute("visibility", "hidden");
+      svg.append(d);
+      return d;
+    });
+    const head = node(host, `position:absolute;left:0;top:0;padding:0.1em 0.35em;font-family:var(--kf-font-mono);font-size:${axisPx}px;font-weight:700;color:var(--kf-on-accent);background:var(--kf-accent);white-space:nowrap;font-variant-numeric:tabular-nums`);
+    const xl = [0, n - 1].map((i) => node(host, `position:absolute;top:${ctop + ch + axisPx * 0.4}px;left:${xy[i][0]}px;transform:translateX(${i ? "-100%" : "0"});font-family:var(--kf-font-mono);font-size:${axisPx}px;color:var(--kf-dim, var(--kf-ink));white-space:nowrap`, pts[i].x));
+    const mi = c.mark ? pts.findIndex((p) => p.x === c.mark!.x) : -1;
+    const markEl = mi >= 0 ? (() => {
+      const [x, y] = xy[mi];
+      const rule = node(host, `position:absolute;left:${x - 2}px;top:${ctop}px;width:4px;height:${ch}px;background:var(--kf-ink);opacity:.5;transform-origin:50% 100%`);
+      const chip = node(host, `position:absolute;left:${x}px;top:${Math.max(ctop, y - axisPx * 3.2)}px;transform:translateX(${mi > n / 2 ? "-105%" : "5%"});padding:0.12em 0.4em;font-family:var(--kf-font-sans);font-size:${Math.round(axisPx * 1.2)}px;font-weight:700;color:var(--kf-on-accent);background:var(--kf-accent);white-space:nowrap`);
+      return { rule, chip };
+    })() : null;
+
+    const drawFrom = 0.1;
+    // 끝 값이 앉는 몫(쓰기 0.3초 + 앉기)만 남기고 선이 장면을 거의 다 쓴다
+    const drawEnd = ctx.dur - 0.25;
+    const at = (i: number) => drawFrom + ((drawEnd - drawFrom) * i) / (n - 1);
+    const markAt = mi >= 0 ? at(mi) : Infinity;
+    const writeMark = markEl ? slots.write(markEl.chip, { ctx, text: c.mark!.label, at: markAt, dur: 0.3, seed: `${kit.seed}:mark` }) : null;
+    const writeBig = slots.write(big, { ctx, text: last, at: drawEnd - 0.2, dur: 0.3, seed: `${kit.seed}:big` });
+    const landed = slots.land(big, { ctx, at: drawEnd + 0.1, seed: `${kit.seed}:land` });
+
+    return (t: number) => {
+      moving("trend.draw", ctx);
+      // 고른 빠르기로 — 점 사이 거리가 아니라 점 차례로 시각을 나눠 점마다 같은 몫
+      const q = clamp((t - drawFrom) / (drawEnd - drawFrom)) * (n - 1);
+      const k = Math.floor(q);
+      const f = q - k;
+      const drawn: [number, number][] = xy.slice(0, k + 1).map((p) => [p[0], p[1]]);
+      if (k < n - 1) drawn.push(...partial([xy[k], xy[k + 1]], f).slice(1));
+      const ptsAttr = drawn.map((p) => `${p[0].toFixed(1)},${p[1].toFixed(1)}`).join(" ");
+      linePoly.setAttribute("points", t >= drawFrom ? ptsAttr : "");
+      const tail = drawn[drawn.length - 1];
+      fillPoly.setAttribute("points", t >= drawFrom ? `${cx},${ctop + ch} ${ptsAttr} ${tail[0].toFixed(1)},${ctop + ch}` : "");
+      dots.forEach((d, i) => d.setAttribute("visibility", t >= at(i) ? "visible" : "hidden"));
+      const passed = Math.min(n - 1, Math.max(0, Math.floor(q + 1e-6)));
+      head.textContent = `${fmt(pts[passed].y, dec)}${unit ? ` ${unit}` : ""}`;
+      head.style.transform = `translate(${tail[0].toFixed(1)}px, ${(tail[1] - dotR * 2).toFixed(1)}px) translate(${tail[0] > cx + cw * 0.8 ? "-100%" : "-50%"}, -100%)`;
+      head.style.visibility = t >= drawFrom && t < drawEnd + 0.3 ? "visible" : "hidden";
+      for (const e of xl) e.style.visibility = t >= drawFrom ? "visible" : "hidden";
+      if (markEl) {
+        markEl.rule.style.visibility = t >= markAt ? "visible" : "hidden";
+        markEl.chip.style.visibility = t >= markAt ? "visible" : "hidden";
+        applyStyle(markEl.rule, { scaleY: clamp((t - markAt) / 0.25) });
+        writeMark?.(t);
+      }
+      writeBig(t);
+      applyStyle(big, landed(t));
+      big.style.visibility = t >= drawEnd - 0.2 ? "visible" : "hidden";
+    };
+  },
+};
+
+export default pattern;

package/packages/patterns/src/types.ts

@@ -0,0 +1,67 @@
+import type { SceneCtx, Style } from "@kasaframe/core";
+import type { ThemeSlots } from "@kasaframe/themes/slots";
+
+// 감독 packages/director/src/pattern.ts 와 같은 꼴(구조로 맞춘다). 감독이 패키지로 서면 그쪽 꼴을 import type 으로 받는다 — slots 만 테마 슬롯 꼴로 좁힌다.
+
+export type Energy = "low" | "mid" | "high";
+export type Family = "slam" | "flap" | "grow" | "draw" | "type" | "pop" | "mask" | "flow" | "stack" | "morph";
+export type CameraKind = "none" | "pushIn" | "pullOut" | "follow" | "impact";
+export type AspectName = "16:9" | "9:16" | "1:1";
+export type TextPolicy = "none" | "terms-only" | "captions" | "lyrics";
+
+export interface FitInfo {
+  aspect: AspectName;
+  dur: number;
+  policy: TextPolicy;
+}
+
+export interface StageLike {
+  box: HTMLDivElement;
+  cam: HTMLDivElement;
+  safeW: number;
+  safeH: number;
+  vertical: boolean;
+  camera: {
+    pushIn(at: number, o?: { to?: unknown; scale?: number; dur?: number }): unknown;
+    pullOut(at: number, o?: { to?: unknown; scale?: number; dur?: number }): unknown;
+    follow(target: unknown, from: number, to: number, o?: { scale?: number }): unknown;
+    impact(at: number, o?: { amount?: number; dur?: number }): unknown;
+  };
+  hero(el: HTMLElement): HTMLElement;
+}
+
+export interface SpokenWord {
+  text: string;
+  from: number;
+  to: number;
+}
+
+export interface Kit {
+  seed: string;
+  hits: number[];
+  say: SpokenWord[];
+  slots: ThemeSlots;
+  stage: StageLike;
+  policy: TextPolicy;
+  first: boolean;
+  last: boolean;
+  loop: boolean;
+}
+
+export interface Pattern<C = any> {
+  id: string;
+  type: string;
+  does: string;
+  energy: Energy[];
+  family: Family;
+  camera: CameraKind[];
+  bg: "stage" | "own";
+  aspects: AspectName[];
+  dur: { min: number; max: number };
+  themes?: Record<string, number>;
+  purposes?: { prefer?: string[]; avoid?: string[] };
+  fits?(content: C, info: FitInfo): true | string;
+  build(root: HTMLElement, ctx: SceneCtx, content: C, kit: Kit): (t: number) => void;
+}
+
+export type { SceneCtx, Style, ThemeSlots };

package/packages/patterns/src/words/moves.ts

@@ -0,0 +1,42 @@
+import { dressText } from "@kasaframe/motion/moves";
+import { area, moving, node } from "../kit.ts";
+import type { Energy, Family, Pattern } from "../types.ts";
+
+export interface WordsContent {
+  words: string[];
+}
+
+// 낱말 리듬은 연출 수 메뉴(@kasaframe/motion/moves dress)의 글 수가 이미 박에 맞춰 검사를 넘긴 값으로 그린다 — 패턴은 고를 수 있는 이름과
+// 고르는 표(에너지·계열)만 붙인다. 수마다 낱말 수·길이 한계가 다르다. ghostStack·splitFlap 은 세로 밝은 테마에서 멈춤 검사를 못 넘어 아직 안 건다
+function wordsPattern(o: { name: string; move: string; does: string; energy: Energy[]; family: Family; max: number; maxLen: number }): Pattern<WordsContent> {
+  return {
+    id: `words.${o.name}`,
+    type: "words",
+    does: o.does,
+    energy: o.energy,
+    family: o.family,
+    camera: ["none"],
+    bg: "stage",
+    aspects: ["16:9", "9:16", "1:1"],
+    dur: { min: 1.2, max: 9 },
+    fits(c) {
+      const ws = (c?.words ?? []).filter((x) => typeof x === "string" && x.trim());
+      if (!ws.length) return "words 가 비었다";
+      if (ws.length > o.max) return `낱말이 ${o.max}개를 넘는다`;
+      if (ws.some((x) => [...x].length > o.maxLen)) return `낱말 하나가 ${o.maxLen}자를 넘는다`;
+      return true;
+    },
+    build(root, ctx, c, kit) {
+      const { w, h } = area(ctx, kit);
+      const host = node(root, "position:absolute;inset:0");
+      const paint = dressText(o.move, host, ctx, { words: c.words, w, h, ready: kit.first }) ?? (() => {});
+      kit.stage?.hero(host);
+      return (t: number) => {
+        moving(`words.${o.name}`, ctx);
+        paint(t);
+      };
+    },
+  };
+}
+
+export const wordsSlam = wordsPattern({ name: "slam", move: "slamWords", does: "박마다 낱말 하나가 화면 띠를 꽉 채우며 쾅 — 판과 글색이 뒤집힌다", energy: ["high"], family: "slam", max: 6, maxLen: 10 });

package/packages/patterns/src/words/slam.ts

@@ -0,0 +1,4 @@
+import { wordsSlam } from "./moves.ts";
+
+// 장면 파일이 @kasaframe/patterns/words/slam 로 가져간다
+export default wordsSlam;

package/packages/plan/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@kasaframe/plan",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@kasaframe/core": "*",
+    "@kasaframe/gen": "*",
+    "@kasaframe/motion": "*",
+    "@kasaframe/themes": "*"
+  }
+}

package/packages/plan/src/asks.ts

@@ -0,0 +1,256 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { byMood, estimateImageUsd, howToGet, listLibrary, musicQuestion, ttsProviders, videoProviders, voiceQuestion, WAIT, type CapabilityReport, type Choice, type Question, type VideoRequest } from "@kasaframe/gen";
+import { listThemes, sheetDir, themeDims, themeSample } from "@kasaframe/themes";
+import { loadSeries } from "./series.ts";
+import { loadTemplate } from "./templates.ts";
+import { suggestThemes, themeFromRequest } from "./themes.ts";
+import type { Plan } from "./types.ts";
+
+// 계획이 쓰려는 능력을 지금 있는 능력에 맞춘다 — 돈이 들거나 없거나 제한이 걸린 것만 묻고, 나머지는 바로 정한다(auto)
+export interface PlanQuestions {
+  questions: Question[];
+  auto: Record<string, string>; // 물을 것 없이 정해진 답(공짜로 있는 능력)
+}
+
+export { WAIT };
+
+// 없는 능력 — 조용히 대체하지 않는다. ① 넣는 법(권장) ② 지금 쓸 수 있는 다른 엔진 ③ 빼기를 나란히 두고 사람이 고른다
+function missing(q: Omit<Question, "default" | "skip" | "missing" | "choices">, install: Choice, others: Choice[], drop: Choice): Question {
+  return { ...q, choices: [install, ...others, drop], default: WAIT, skip: drop.value, missing: true };
+}
+
+const money = (n: number) => (n < 0.1 ? `$${n.toFixed(3)}` : `$${n.toFixed(2)}`);
+const ids = (xs: { id: string }[]) => xs.map((x) => x.id).join("·");
+
+function imageQuestion(plan: Plan, caps: CapabilityReport): { q?: Question; auto?: string } {
+  const imgs = plan.gen.filter((g) => g.kind === "img");
+  if (!imgs.length) return {};
+  const ready = caps.providers.filter((p) => p.ready);
+  const og = ready.find((p) => p.id.startsWith("og-"));
+  const codex = ready.find((p) => p.id === "codex-imagegen");
+  const none: Choice = { value: "none", label: "그림 없이", note: "받은 자산·도형·실제 화면 오리기로 장면을 채운다" };
+  if (og) {
+    const usd = imgs.reduce((n, g) => n + estimateImageUsd({ prompt: "", size: g.size ?? `${plan.width}x${plan.height}`, quality: g.quality ?? "high", refs: g.refs }), 0);
+    return {
+      q: {
+        id: "image",
+        cap: "image",
+        header: "그림 생성",
+        ask: `그림 ${imgs.length}장(${ids(imgs)})을 OG gpt-image 로 만들까? 견적 최대 ${money(usd)}`,
+        choices: [
+          { value: og.id, label: `OG ${og.id.replace(/^og-/, "")}`, costUsd: usd, note: "장당 20–30초" },
+          ...(codex ? [{ value: codex.id, label: "codex imagegen", costUsd: 0, note: "ChatGPT 요금제 안 — 장당 1–2분" }] : []),
+          none,
+        ],
+        default: og.id,
+        skip: "none",
+        flag: "--image",
+      },
+    };
+  }
+  // 기본 그림 모델(OG)이 없다 — codex 가 있어도 조용히 넘어가지 않고 다른 엔진 보기로 둔다
+  return {
+    q: missing(
+      { id: "image", cap: "image", header: "그림 모델", ask: `그림 ${imgs.length}장(${ids(imgs)})을 만들 기본 그림 모델(OG gpt-image)이 없다`, flag: "--image" },
+      { value: WAIT, label: "키를 넣고 다시", note: `${howToGet("opengateway")}${codex ? "" : " · 또는 0원 codex: npm i -g @openai/codex && codex login(ChatGPT 계정)"}` },
+      codex ? [{ value: codex.id, label: "codex imagegen 으로", costUsd: 0, note: "ChatGPT 로그인 — 0원, 장당 1–2분" }] : [],
+      none,
+    ),
+  };
+}
+
+function videoQuestion(plan: Plan, caps: CapabilityReport): { q?: Question; auto?: string } {
+  const vids = plan.gen.filter((g) => g.kind === "vid");
+  if (!vids.length) return {};
+  const scene = (id?: string) => plan.scenes.find((s) => s.id === id);
+  const reqs: VideoRequest[] = vids.map((g) => ({
+    prompt: g.prompt,
+    duration: g.seam ? (scene(g.scene)?.dur ?? 5) : (g.dur ?? 5),
+    aspect: plan.aspect,
+    ...(g.seam || g.first ? { firstFrame: "x" } : {}),
+    ...(g.seam || g.last ? { lastFrame: "y" } : {}),
+  }));
+  const ready = new Set(caps.providers.filter((p) => p.ready).map((p) => p.id));
+  const restrict = new Map(caps.providers.map((p) => [p.id, p.restrict]));
+  const options = videoProviders()
+    .filter((p) => ready.has(p.id))
+    .filter((p) => reqs.every((r) => !r.lastFrame || p.firstLast))
+    .map((p) => ({ p, usd: reqs.reduce((n, r) => n + p.estimateUsd(r), 0), restrict: restrict.get(p.id) }))
+    .sort((a, b) => a.usd - b.usd);
+  const open = options.filter((o) => !o.restrict);
+  const limited = options.filter((o) => o.restrict);
+  const what = `영상 모델 컷 ${vids.length}개(${vids.map((g) => `${g.id}${g.seam ? " 이음매" : ""}`).join("·")})`;
+  const none: Choice = { value: "none", label: "영상 모델 없이", note: "이음매는 three 3D 전환, 움직임 컷은 그림·모션그래픽으로" };
+  if (!options.length) {
+    return {
+      q: missing(
+        { id: "video", cap: "video", header: "영상 모델", ask: `${what}를 만들 영상 모델이 없다`, flag: "--video" },
+        { value: WAIT, label: "키를 넣고 다시", note: `${howToGet("fal")} · 또는 ${howToGet("gemini")} · 사내 ${howToGet("h3")}` },
+        [],
+        none,
+      ),
+    };
+  }
+  // 돈도 제한도 없는 길이 있으면 묻지 않는다(아직 그런 공급자는 없다 — H3 는 0원이지만 지역 제한이 걸린다)
+  if (open[0] && open[0].usd === 0) return { auto: open[0].p.id };
+  const choices: Choice[] = [
+    ...open.slice(0, 2).map((o) => ({ value: o.p.id, label: o.p.id, costUsd: o.usd })),
+    ...limited.slice(0, 1).map((o) => ({ value: o.p.id, label: `${o.p.id}(사내 파드)`, costUsd: o.usd, note: o.restrict })),
+    none,
+  ];
+  return {
+    q: {
+      id: "video",
+      cap: "video",
+      header: "영상 모델",
+      ask: open.length ? `${what} — ${open[0].p.id} 로 만들까? 견적 ${money(open[0].usd)}` : `${what} — 쓸 수 있는 건 지역 제한이 걸린 것뿐이다`,
+      choices: choices.slice(0, 4),
+      // 제한 걸린 길은 사람이 짚어야만 — --yes 로 회사·바깥 결과물에 섞이지 않게
+      default: open[0]?.p.id ?? "none",
+      skip: "none",
+      flag: "--video",
+    },
+  };
+}
+
+function blenderQuestion(plan: Plan, caps: CapabilityReport): { q?: Question; auto?: string } {
+  if (!plan.shots?.length) return {};
+  const b = caps.providers.find((p) => p.id === "blender");
+  if (b?.ready) return { auto: "blender" };
+  return {
+    q: missing(
+      { id: "blender", cap: "blender", header: "3D 샷", ask: `주인공 3D 장면(${plan.shots.map((s) => s.scene).join("·")})을 구울 Blender 가 없다 — ${b?.detail ?? "못 찾음"}`, flag: "--blender" },
+      { value: WAIT, label: "Blender 를 깔고 다시", note: `${b?.fix ?? "blender.org 에서 4.3 이상"} — 확인은 kf doctor 「생성 능력」` },
+      [{ value: "three", label: "three.js 로", note: "장면 안에서 stage3d 로 3D 를 짓는다(툰 셰이딩·라인아트는 없다)" }],
+      { value: "none", label: "3D 없이", note: "2D 모션그래픽 장면으로" },
+    ),
+  };
+}
+
+// 목소리 — 틀이 내레이션을 켰을 때만. 시리즈가 박은 목소리는 사람이 미리 준 답이라 그 엔진이 있으면 묻지 않는다.
+// 그 밖엔 늘 묻는다(목소리는 결이라 돈이 안 들어도) — 보기 차례는 voiceQuestion(로컬 Qwen3·ElevenLabs·자막만·그 밖)
+function voicePart(plan: Plan, caps: CapabilityReport): { q?: Question; auto?: string } {
+  const n = loadTemplate(plan.purpose).narration;
+  if (!n?.on || plan.voice) return {};
+  const ready = caps.providers.filter((p) => p.ready).map((p) => p.id);
+  const want = plan.series ? loadSeries(plan.series).voice : undefined;
+  if (!want) return n.voice === "none" ? { auto: "none" } : { q: voiceQuestion({ voices: n.voices, ready }) };
+  if (want === "none") return { auto: "none" };
+  const engine = want.split(":")[0];
+  if (ready.includes(engine)) return { auto: want };
+  const p = ttsProviders().find((x) => x.id === engine);
+  const others = ttsProviders().filter((x) => ready.includes(x.id)).slice(0, 2);
+  return {
+    q: missing(
+      { id: "voice", cap: "voice", header: "목소리", ask: `시리즈 목소리 ${want}(${p?.label ?? engine})을 이 기계에서 못 쓴다`, flag: "--voice", accepts: (v: string) => v === "none" || ready.includes(v.split(":")[0]) },
+      { value: WAIT, label: `${p?.label ?? engine} 키를 넣고 다시`, note: howToGet(p?.keyName ?? engine) },
+      others.map((x) => {
+        const v = n.voices[x.id] ?? x.defaultVoice;
+        return { value: `${x.id}:${v}`, label: `${x.label} ${v} 로`, costUsd: x.estimateUsd("가".repeat(300)), note: `시리즈 목소리(${want})와 다르다 — 같은 시리즈의 다른 영상과 목소리가 달라진다` };
+      }),
+      { value: "none", label: "목소리 없이 — 자막만", costUsd: 0 },
+    ),
+  };
+}
+
+// 테마 — 시리즈가 정했거나 요청이 「리소 느낌」처럼 짚었으면 묻지 않는다(kf new 의 auto 가 그대로 짚은 테마를 쓴다).
+// 보기는 「알아서」(= auto, 권장)와 이 용도·화면비의 approved 테마 전부(요청에 맞는 차례) — theme.json status 만 approved 로 바꾸면 들어온다
+function themePart(plan: Plan): { q?: Question; auto?: string } {
+  if ((plan.series && loadSeries(plan.series).theme) || themeFromRequest(plan.request, plan.purpose)) return {};
+  const ranked = suggestThemes(plan.request, plan.purpose, plan.aspect, Infinity);
+  if (!ranked.length) return {};
+  const byId = new Map(listThemes({ status: "approved" }).map((t) => [t.id, t]));
+  const grid = join(sheetDir, "sheet.png");
+  const first = byId.get(ranked[0].id)!;
+  return {
+    q: {
+      id: "theme",
+      cap: "theme",
+      header: "테마",
+      ask: `테마는? ${existsSync(grid) ? `같은 문장 한 장면을 테마마다 찍은 견본 시트 ${grid}` : "보기마다 견본 그림 경로"}`,
+      choices: [
+        { value: "auto", label: "알아서", note: `요청 낱말에 맞는 approved 테마를 고른다 — 지금이면 ${first.name}` },
+        ...ranked.map(({ id }) => {
+          const t = byId.get(id)!;
+          const sample = themeSample(t);
+          return { value: t.id, label: `${t.name} · ${themeDims(t)}`, note: `${t.metaphor}${sample ? ` — 견본 ${sample}` : ""}` };
+        }),
+      ],
+      default: "auto",
+      skip: "auto",
+      flag: "--theme",
+      // 보기 밖이라도 사람이 짚은 review 테마·none(프리셋만)은 받는다 — kf new --theme 과 같은 범위
+      accepts: (v: string) => v === "none" || listThemes({ status: ["approved", "review"] }).some((t) => t.id === v),
+    },
+  };
+}
+
+// 곡 — 틀이 분위기를 정한 용도만. 시리즈 곡·분위기 맞는 곡 모음 곡(0원·늘 같은 곡)은 묻지 않는다.
+// 없으면 생성(돈)·곡 넣기·없음을 묻고, 생성 키도 없으면 다른 분위기 곡·「곡 없이」로 조용히 넘어가지 않고 missing 으로 묻는다
+function musicPart(plan: Plan, caps: CapabilityReport): { q?: Question; auto?: string } {
+  // 시리즈가 정한 분위기가 틀 분위기를 덮는다 — 같은 시리즈면 같은 곡
+  const mood = plan.mood ?? loadTemplate(plan.purpose).mood;
+  if (!mood || plan.music) return {};
+  const file = plan.series ? loadSeries(plan.series).music?.file : undefined;
+  if (file) return { auto: fileURLToPath(new URL(`../../../${file}`, import.meta.url)) };
+  const lib = byMood(mood);
+  if (lib.length) return { auto: lib[0].path };
+  const ready = caps.providers.filter((p) => p.ready && p.id !== "library").map((p) => p.id);
+  const put: Choice = { value: WAIT, label: "곡을 넣고 다시", note: `kf music add <곡> --mood ${mood} --source <원본> --license "<라이선스>" 로 곡 모음에 넣거나 --music <곡 파일>` };
+  const q = musicQuestion({ mood, duration: plan.duration, ready });
+  if (ready.length) return { q: { ...q, choices: [q.choices[0], put, ...q.choices.slice(1)].slice(0, 4) } };
+  const { default: _d, skip: _s, choices: _c, ...head } = q;
+  return {
+    q: missing(
+      { ...head, ask: `분위기 ${mood} 에 맞는 곡이 곡 모음에 없고 음악 생성 키도 없다` },
+      { ...put, label: "곡이나 생성 키를 넣고 다시", note: `${put.note} · 생성은 ${howToGet("gemini")}(Lyria 3.5, 유료 등급) 또는 ${howToGet("elevenlabs")}(Eleven Music)` },
+      listLibrary().filter((t) => t.license && t.mood.length).slice(0, 1).map((t) => ({ value: t.path, label: `곡 모음 「${t.title}」로`, costUsd: 0, note: `틀 분위기(${mood})와 다른 곡(${t.mood.join("·")}) — ${t.license}` })),
+      { value: "none", label: "곡 없이", costUsd: 0 },
+    ),
+  };
+}
+
+export function planQuestions(plan: Plan, caps: CapabilityReport[]): PlanQuestions {
+  const by = (c: string) => caps.find((x) => x.cap === c) ?? { cap: c, label: c, providers: [], best: null };
+  const parts: [string, { q?: Question; auto?: string }][] = [
+    ["theme", themePart(plan)],
+    ["image", imageQuestion(plan, by("image") as CapabilityReport)],
+    ["video", videoQuestion(plan, by("video") as CapabilityReport)],
+    ["blender", blenderQuestion(plan, by("blender") as CapabilityReport)],
+    ["voice", voicePart(plan, by("voice") as CapabilityReport)],
+    ["music", musicPart(plan, by("music") as CapabilityReport)],
+  ];
+  const out: PlanQuestions = { questions: [], auto: {} };
+  for (const [id, r] of parts) {
+    if (r.q) out.questions.push(r.q);
+    else if (r.auto) out.auto[id] = r.auto;
+  }
+  return out;
+}
+
+// 답대로 계획을 고친다 — 빼기로 한 능력의 만들 거리를 지우고, 고른 공급자를 적는다. wait 를 고른 질문은 stop 으로 돌려준다
+export function applyAnswers(plan: Plan, answers: Record<string, string>, questions: Question[] = []): { plan: Plan; stop: string[] } {
+  const stop = questions.filter((q) => answers[q.id] === WAIT).map((q) => `${q.ask} — ${q.choices.find((c) => c.value === WAIT)?.note ?? ""}`);
+  const p: Plan = { ...plan, answers: { ...(plan.answers ?? {}), ...answers } };
+  const drop = (kind: "img" | "vid") => {
+    const gone = new Set(p.gen.filter((g) => g.kind === kind).map((g) => g.id));
+    p.gen = p.gen.filter((g) => g.kind !== kind);
+    p.scenes = p.scenes.map((s) => ({ ...s, assets: s.assets.filter((a) => !gone.has(a.replace(/^gen:(img|vid):/, ""))) }));
+    // 지운 그림을 첫 프레임으로 기다리던 영상은 글만으로 간다
+    if (kind === "img") p.gen = p.gen.map((g) => (g.first && gone.has(g.first.replace(/^assets\/gen\/|\.png$/g, "")) ? { ...g, first: undefined } : g));
+  };
+  const pick = (kind: "img" | "vid", v?: string) => {
+    if (!v || v === WAIT) return;
+    if (v === "none") drop(kind);
+    else p.gen = p.gen.map((g) => (g.kind === kind ? { ...g, provider: v } : g));
+  };
+  pick("img", answers.image);
+  pick("vid", answers.video);
+  // 목소리·곡은 kf narrate 가 읽는 칸으로 — 곡 파일 경로는 kf new 가 곡으로 깔고, gen:·none 은 narrate 가 처리한다
+  if (answers.voice && answers.voice !== WAIT) p.voice = answers.voice;
+  if (answers.blender === "none") p.shots = [];
+  else if (answers.blender === "three") p.shots = (p.shots ?? []).map((s) => ({ ...s, tool: "three" }));
+  return { plan: p, stop };
+}