voxflow 1.15.4 → 1.15.6

package/dist/templates/data-finding/deck.json

@@ -0,0 +1,40 @@
+{
+  "header": "数据发现",
+  "seriesTitle": "一个反直觉数字",
+  "seriesTagline": "看完你大概率会改方法",
+  "theme": "bold-poster",
+  "cards": [
+    {
+      "kind": "title",
+      "title": ["90%", "其实是错的"],
+      "narration": "我们查了一千个团队的工时表，发现一个反直觉的数字。"
+    },
+    {
+      "kind": "data",
+      "data": {
+        "value": "47",
+        "unit": "%",
+        "label": "时间花在等其他人决策"
+      },
+      "narration": "受访的产品经理里，平均 47% 的工时不是在做事，是在等其他人拍板。"
+    },
+    {
+      "kind": "body",
+      "caption": "瓶颈不在产能，在决策",
+      "figureKeyword": "decision-fork",
+      "narration": "团队越大，决策的链路越长，工时就越多地耗在等待。"
+    },
+    {
+      "kind": "body",
+      "caption": "把决策权下放到能做的人",
+      "figureKeyword": "owner-deadline",
+      "narration": "解法不复杂：明确谁能拍板，让 ta 不必再等上级签字。"
+    },
+    {
+      "kind": "body",
+      "caption": "47% 是可以拿回来的",
+      "figureKeyword": "growth-system",
+      "narration": "下调一层决策权之后，工时回收的中位数是 22%。值得动一下。"
+    }
+  ]
+}

package/dist/templates/founder-lesson/deck.json

@@ -0,0 +1,37 @@
+{
+  "header": "创业 · 复盘",
+  "seriesTitle": "一个人创业",
+  "seriesTagline": "回看一年前的自己",
+  "theme": "editorial-mag",
+  "cards": [
+    {
+      "kind": "title",
+      "title": ["最重要的事", "不是技术"],
+      "narration": "一年前我以为是技术决定生死，一年后才发现真正的决定者是别的。"
+    },
+    {
+      "kind": "body",
+      "caption": "把功能写得太多",
+      "figureKeyword": "stuck",
+      "narration": "前半年我加了二十个功能，用户记得的只有三个。剩下的成了我的债务。"
+    },
+    {
+      "kind": "body",
+      "caption": "把用户的话当作功能列表",
+      "figureKeyword": "problem-framing",
+      "narration": "用户说什么我就做什么，没意识到他们说的是问题，不是答案。"
+    },
+    {
+      "kind": "body",
+      "caption": "把孤独当作专注的代价",
+      "figureKeyword": "thinking",
+      "narration": "一个人写完所有代码，但没有人和我讨论方向，慢慢就走偏了。"
+    },
+    {
+      "kind": "body",
+      "caption": "现在每周强制和三个用户聊",
+      "figureKeyword": "team-alignment",
+      "narration": "现在每周固定和三个真实用户聊半小时，比写代码更影响下一步。"
+    }
+  ]
+}

package/dist/templates/incident-review/deck.json

@@ -0,0 +1,37 @@
+{
+  "header": "线上事故 · 复盘",
+  "seriesTitle": "一次三小时的宕机",
+  "seriesTagline": "我们认了，下次不会再这样",
+  "theme": "brutalist",
+  "cards": [
+    {
+      "kind": "title",
+      "title": ["3 小时宕机", "我们的复盘"],
+      "narration": "周二晚上九点，我们的服务挂了三个小时。这是怎么发生的。"
+    },
+    {
+      "kind": "body",
+      "caption": "一次例行发布触发了 OOM",
+      "figureKeyword": "risk-guardrail",
+      "narration": "晚上 21:08 上线了一个新功能，新代码在峰值流量下吃掉了所有内存。"
+    },
+    {
+      "kind": "body",
+      "caption": "告警没响，监控盲区",
+      "figureKeyword": "evidence-board",
+      "narration": "OOM 杀死了进程但没杀掉容器，健康检查仍然通过，告警延迟了 40 分钟。"
+    },
+    {
+      "kind": "body",
+      "caption": "回滚花了一小时，因为没演练过",
+      "figureKeyword": "timeline-review",
+      "narration": "我们有回滚脚本，但从来没真正跑过，第一次跑发现配置漂移了，又花一小时手动修。"
+    },
+    {
+      "kind": "body",
+      "caption": "三件改变：金丝雀、内存告警、月度演练",
+      "figureKeyword": "learning-loop",
+      "narration": "下个版本起：所有发布走 5% 金丝雀；监控加内存阈值；每月演练一次回滚。"
+    }
+  ]
+}

package/dist/templates/manifest.json

@@ -0,0 +1,45 @@
+{
+  "version": 1,
+  "templates": [
+    {
+      "id": "product-launch",
+      "name": "Product launch story",
+      "theme": "paper-slide",
+      "description": "Five-card narrative arc for a startup launch — pain → insight → demo → result → CTA. Best for 抖音 / 视频号 / 小红书 knowledge-card content.",
+      "lang": "zh",
+      "tags": ["startup", "launch", "narrative"]
+    },
+    {
+      "id": "founder-lesson",
+      "name": "Founder lesson (look-back)",
+      "theme": "editorial-mag",
+      "description": "Quiet hindsight from a solo founder. Magazine-style editorial fit for 知乎 / 公众号 / LinkedIn long-form readers.",
+      "lang": "zh",
+      "tags": ["founder", "hindsight", "essay"]
+    },
+    {
+      "id": "data-finding",
+      "name": "Surprising stat",
+      "theme": "bold-poster",
+      "description": "Bold-poster card that opens on a surprising number, then breaks it down. Best for X / Threads / LinkedIn where a single visual carries the room.",
+      "lang": "zh",
+      "tags": ["data", "number", "headline"]
+    },
+    {
+      "id": "incident-review",
+      "name": "Incident post-mortem",
+      "theme": "brutalist",
+      "description": "Brutalist black-and-white deck for an honest post-mortem — what happened, why, what changes. Best for engineering team channels / 即刻 / Mastodon.",
+      "lang": "zh",
+      "tags": ["postmortem", "engineering", "candor"]
+    },
+    {
+      "id": "quiet-essay",
+      "name": "Late-night reflection",
+      "theme": "atmospheric",
+      "description": "Atmospheric one-light-source vibe for personal essay. Best for 即刻 / 微博 / 播客 closing thoughts.",
+      "lang": "zh",
+      "tags": ["essay", "reflection", "mood"]
+    }
+  ]
+}

package/dist/templates/product-launch/deck.json

@@ -0,0 +1,37 @@
+{
+  "header": "产品发布",
+  "seriesTitle": "我们做了一年的东西",
+  "seriesTagline": "上线第一天的真心话",
+  "theme": "paper-slide",
+  "cards": [
+    {
+      "kind": "title",
+      "title": ["十年的痛", "今天有个答案"],
+      "narration": "我们做了一整年的东西，今天上线。先讲讲为什么要做。"
+    },
+    {
+      "kind": "body",
+      "caption": "重复的活，每天都在做",
+      "figureKeyword": "stuck",
+      "narration": "团队里有 30% 的时间花在同一件事上：把素材塞进同一个模板。"
+    },
+    {
+      "kind": "body",
+      "caption": "工具早就有，但用起来割裂",
+      "figureKeyword": "decision-fork",
+      "narration": "市面上有十几个工具能做这个分工，但每多一个工具，团队学习成本翻倍。"
+    },
+    {
+      "kind": "body",
+      "caption": "我们把它合并到一个对话",
+      "figureKeyword": "team-alignment",
+      "narration": "今天发布的版本，把这些动作统一在一个 Claude Code 会话里。"
+    },
+    {
+      "kind": "body",
+      "caption": "30 分钟出片，0 模板锁定",
+      "figureKeyword": "growth-system",
+      "narration": "首批用户的反馈是平均 30 分钟从想法到成片，比之前快五倍。"
+    }
+  ]
+}

package/dist/templates/quiet-essay/deck.json

@@ -0,0 +1,37 @@
+{
+  "header": "深夜 · 散文",
+  "seriesTitle": "为什么周末也很累",
+  "seriesTagline": "写给一直没歇的你",
+  "theme": "atmospheric",
+  "cards": [
+    {
+      "kind": "title",
+      "title": ["不是身体在累", "是脑子没下班"],
+      "narration": "周一到周五累不奇怪，奇怪的是周末也累，原因和工作量无关。"
+    },
+    {
+      "kind": "body",
+      "caption": "睡了八小时还是不解乏",
+      "figureKeyword": "stuck",
+      "narration": "明明睡满八小时，醒来还是疲惫，是因为脑子一整晚都在处理白天没结束的事。"
+    },
+    {
+      "kind": "body",
+      "caption": "未结清的小事最耗能",
+      "figureKeyword": "thinking",
+      "narration": "心理学叫蔡格尼克效应，未完成的小事比已完成的大事更占内存。"
+    },
+    {
+      "kind": "body",
+      "caption": "睡前花五分钟把它们写下来",
+      "figureKeyword": "evidence-board",
+      "narration": "解法很轻：睡前花五分钟把脑子里悬着的事写下来，写完它们就先安心地等着。"
+    },
+    {
+      "kind": "body",
+      "caption": "不是认真就行，是让它们不再追你",
+      "figureKeyword": "growth-system",
+      "narration": "你不是要认真处理每件小事，你是要让它们停止半夜还在追你。"
+    }
+  ]
+}

package/lib/commands/slice-fork.js

@@ -0,0 +1,151 @@
+'use strict';
+
+/**
+ * `voxflow slice fork <template-id>` — copy a curated Slice template's
+ * deck.json into the current working directory.
+ *
+ * Templates live under `cli/skills/voxflow-slice/templates/<id>/deck.json`
+ * with a sibling `manifest.json` describing the gallery. The CLI ships
+ * them verbatim (the `files` whitelist in package.json includes `skills/`),
+ * so `npm install voxflow` is enough — no separate download.
+ *
+ * No `meta` export — reached only via `slice.js` dispatch (`voxflow slice
+ * fork <id>`), so it stays out of the registry parity test (same pattern
+ * as slice-stage.js / slice-render.js).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { validatePaperSlideDeck } = require('../internal/deck-validator');
+
+/**
+ * Resolve the on-disk path to the templates directory. Walks the candidate
+ * layouts so the fork command works in both `node bin/voxflow.js` (source
+ * tree at cli/skills/...) and the published npm tarball (ncc dist beside
+ * skills/).
+ */
+function resolveTemplatesDir() {
+  const candidates = [
+    // Source / dev: cli/lib/commands/slice-fork.js → cli/skills/...
+    path.resolve(__dirname, '../../skills/voxflow-slice/templates'),
+    // Published: <pkg>/dist/index.js (bundled) sits beside <pkg>/skills/...
+    path.resolve(__dirname, '../skills/voxflow-slice/templates'),
+    // Alt published layout (some build configs flatten skills/ into dist/)
+    path.resolve(__dirname, 'skills/voxflow-slice/templates'),
+  ];
+  for (const c of candidates) {
+    try {
+      if (fs.statSync(path.join(c, 'manifest.json')).isFile()) return c;
+    } catch { /* try next */ }
+  }
+  throw new Error(
+    'Could not locate slice templates — expected manifest.json at one of:\n  ' +
+    candidates.join('\n  ')
+  );
+}
+
+function loadManifest() {
+  const dir = resolveTemplatesDir();
+  const raw = fs.readFileSync(path.join(dir, 'manifest.json'), 'utf8');
+  let manifest;
+  try { manifest = JSON.parse(raw); }
+  catch (err) { throw new Error(`Could not parse manifest.json: ${err.message}`); }
+  if (!manifest || !Array.isArray(manifest.templates)) {
+    throw new Error('manifest.json missing or has invalid `templates` array');
+  }
+  return { dir, manifest };
+}
+
+function listTemplates({ quiet = false } = {}) {
+  const { manifest } = loadManifest();
+  if (quiet) return manifest.templates;
+  console.log('');
+  console.log('\x1b[36m=== VoxFlow Slice — Curated templates ===\x1b[0m');
+  console.log('');
+  for (const t of manifest.templates) {
+    console.log(`  \x1b[36m${t.id}\x1b[0m  \x1b[2m[${t.theme}]\x1b[0m`);
+    console.log(`    ${t.name}`);
+    console.log(`    \x1b[2m${t.description}\x1b[0m`);
+    console.log('');
+  }
+  console.log('Fork with: \x1b[1mvoxflow slice fork <id>\x1b[0m');
+  console.log('');
+  return manifest.templates;
+}
+
+/**
+ * Copy one template's deck.json to the user's chosen output path.
+ *
+ * @param {string} templateId   Must match `manifest.templates[*].id`.
+ * @param {string} [outputPath] Absolute path; default = `<cwd>/<id>-deck.json`.
+ * @returns {{ templateId, theme, outputPath }}
+ */
+function forkTemplate(templateId, outputPath) {
+  const { dir, manifest } = loadManifest();
+  const tpl = manifest.templates.find((it) => it && it.id === templateId);
+  if (!tpl) {
+    const valid = manifest.templates.map((it) => it.id).join(', ');
+    throw new Error(`Unknown template "${templateId}". Valid: ${valid}`);
+  }
+  const srcPath = path.join(dir, templateId, 'deck.json');
+  let raw;
+  try { raw = fs.readFileSync(srcPath, 'utf8'); }
+  catch (err) { throw new Error(`Template asset missing or unreadable: ${srcPath} (${err.message})`); }
+  let deck;
+  try { deck = JSON.parse(raw); }
+  catch (err) { throw new Error(`Template ${templateId} has invalid JSON: ${err.message}`); }
+  // Validate before copying so a corrupted template fails fast rather than
+  // landing on disk and confusing the user later.
+  validatePaperSlideDeck(deck);
+  // Build the default filename outside `path.resolve` so ncc's static
+  // asset analyzer doesn't rewrite the templated literal as a bundled
+  // asset path (it would land at node_modules/voxflow/dist/cli/<id>-deck.json
+  // instead of the user's cwd). See scripts/check-no-asset-rewrite.js
+  // for the rule. Same fix pattern as resolveServeUrl in slice-render.js.
+  const defaultName = templateId + '-deck.json';
+  const out = outputPath || path.resolve(process.cwd(), defaultName);
+  const outDir = path.dirname(out);
+  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+  fs.writeFileSync(out, raw, 'utf8');
+  return { templateId, theme: tpl.theme, outputPath: out };
+}
+
+async function handle(args) {
+  const { parseFlag } = require('../core/args');
+  if (args.includes('--list') || args.includes('-l')) {
+    listTemplates();
+    return;
+  }
+  const output = parseFlag(args, '--output', '-o');
+  const positional = args.find((a) => !a.startsWith('-') && !a.startsWith('--'));
+  if (!positional) {
+    console.error('Usage: voxflow slice fork <template-id> [--output <out.json>]');
+    console.error('       voxflow slice fork --list');
+    process.exit(1);
+  }
+  let result;
+  try {
+    result = forkTemplate(positional, output ? path.resolve(output) : null);
+  } catch (err) {
+    console.error(`\nslice fork failed: ${err.message}`);
+    process.exit(1);
+  }
+  console.log('');
+  console.log('\x1b[36m=== VoxFlow Slice — Fork ===\x1b[0m');
+  console.log(`Template:  ${result.templateId} (${result.theme})`);
+  console.log(`Wrote:     ${result.outputPath}`);
+  console.log('');
+  console.log('Next:');
+  console.log(`  voxflow slice preview ${result.outputPath}        # browser preview + audition + render`);
+  console.log(`  voxflow slice render ${result.outputPath}         # render directly to mp4`);
+  console.log('');
+}
+
+module.exports = {
+  handle,
+  forkTemplate,
+  listTemplates,
+  loadManifest,
+  resolveTemplatesDir,
+};

package/lib/commands/slice-render.js

@@ -44,6 +44,10 @@ function buildInputProps(deck, opts = {}) {
     // .voiceoverSrc so the composition's <Audio> element fetches it during
     // Remotion's headless render.
     const voiceoverByIdx = opts.voiceoverByIdx || {};
+    // Map of cardIdx → image URL produced by prepareImages (or empty when no
+    // images are registered + no card.imageUrl). Themes that consume slide
+    // .imageUrl (photo-feature / atmospheric) pick it up; others ignore.
+    const imageByIdx = opts.imageByIdx || {};
     const numberBadge = null;
     const cards = deck.cards.map((card, i) => {
         const slide = {
@@ -56,7 +60,12 @@ function buildInputProps(deck, opts = {}) {
             seriesTagline: deck.seriesTagline,
             voiceoverSrc: voiceoverByIdx[i] || null,
             numberBadge,
-            imageUrl: card.imageUrl,
+            // Prefer generated/cached AI image over the deck's flat
+            // card.imageUrl when both are present, so a card that registers
+            // `images: [{...}]` always renders the AI variant. External
+            // imageUrl is the fallback for themes that haven't been wired
+            // to the generation path yet.
+            imageUrl: imageByIdx[i] || card.imageUrl,
         };
         if (deck.variantId) slide.variantId = deck.variantId;
         return { slide, durationSec: card.durationSec || DEFAULT_CARD_SEC };
@@ -186,42 +195,46 @@ async function render(opts) {
     const outputDir = path.dirname(outputPath);
     if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
 
-    // ─── Voiceover prep (Phase 1) ────────────────────────────────────────
-    // Synthesize per-card TTS up front so renderMedia's headless Chromium
-    // can fetch each clip as the composition plays. Reuses the audition
-    // cache so a card the user previewed in stage doesn't pay quota again.
-    // Skip the whole pass on --no-audio (back-compat with Phase 0 silent).
+    // ─── Voiceover + Image prep (Phase 1 + Phase B) ─────────────────────
+    // One localhost media server proxies both TTS audition cache (/audio/)
+    // and image-gen cache (/image/) to Remotion's headless Chromium during
+    // render. Shared so we only burn one port + tear-down hook.
     const includeAudio = opts.noAudio !== true;
+    const includeImages = opts.noImages !== true;
     let voiceoverByIdx = {};
+    let imageByIdx = {};
     let voiceoverServer = null;
     let voiceoverSkipped = [];
-    if (includeAudio) {
+    let imageSkipped = [];
+    if (includeAudio || includeImages) {
         const { createTtsAuditionClient } = require('../stage-core/tts-audition');
-        const { startVoiceoverServer, prepareVoiceovers } = require('../stage-core/voiceover-mux');
-        const audClient = createTtsAuditionClient();
-        voiceoverServer = await startVoiceoverServer({ cacheDir: audClient.cacheDir });
-        let synthCount = 0;
-        let cacheCount = 0;
-        const prep = await prepareVoiceovers({
-            deck,
-            auditionClient: audClient,
-            baseUrl: voiceoverServer.url,
-            onProgress: (p) => {
-                if (p.fromCache) cacheCount += 1; else synthCount += 1;
-                process.stdout.write(
-                    `\r[slice render] voiceover ${p.cardIdx + 1}/${p.total} ` +
-                    `(${p.fromCache ? 'cache' : 'synth'})           `
-                );
-            },
+        const { createImageGenClient } = require('../stage-core/image-gen');
+        const { startVoiceoverServer, prepareVoiceovers, prepareImages } = require('../stage-core/voiceover-mux');
+        const audClient = includeAudio ? createTtsAuditionClient() : null;
+        const imgClient = includeImages ? createImageGenClient() : null;
+        voiceoverServer = await startVoiceoverServer({
+            cacheDir: audClient ? audClient.cacheDir : require('os').tmpdir(),
+            imageCacheDir: imgClient ? imgClient.cacheDir : null,
         });
-        voiceoverByIdx = prep.byIdx;
-        voiceoverSkipped = prep.skipped;
-        if (synthCount > 0 || cacheCount > 0) process.stdout.write('\n');
-        if (Object.keys(voiceoverByIdx).length === 0) {
+        if (includeAudio) {
+            const prep = await prepareVoiceovers({
+                deck,
+                auditionClient: audClient,
+                baseUrl: voiceoverServer.url,
+                onProgress: (p) => {
+                    process.stdout.write(
+                        `\r[slice render] voiceover ${p.cardIdx + 1}/${p.total} ` +
+                        `(${p.fromCache ? 'cache' : 'synth'})           `
+                    );
+                },
+            });
+            voiceoverByIdx = prep.byIdx;
+            voiceoverSkipped = prep.skipped;
+            if (Object.keys(voiceoverByIdx).length > 0) process.stdout.write('\n');
             const fatal = voiceoverSkipped.find(
                 (s) => s.reason === 'not_logged_in' || s.reason === 'quota_exceeded'
             );
-            if (fatal) {
+            if (fatal && Object.keys(voiceoverByIdx).length === 0) {
                 console.warn(
                     `[slice render] ⚠ audio skipped — ${fatal.reason}` +
                     (fatal.message ? `: ${fatal.message}` : '') +
@@ -229,10 +242,37 @@ async function render(opts) {
                 );
             }
         }
+        if (includeImages) {
+            const prep = await prepareImages({
+                deck,
+                imgClient,
+                baseUrl: voiceoverServer.url,
+                onProgress: (p) => {
+                    process.stdout.write(
+                        `\r[slice render] image ${p.cardIdx + 1}/${p.total} ` +
+                        `(${p.fromCache ? 'cache' : 'gen'})              `
+                    );
+                },
+            });
+            imageByIdx = prep.byIdx;
+            imageSkipped = prep.skipped;
+            if (Object.keys(imageByIdx).length > 0) process.stdout.write('\n');
+            const fatalImg = imageSkipped.find(
+                (s) => s.reason === 'not_logged_in' || s.reason === 'quota_exceeded'
+            );
+            if (fatalImg && Object.keys(imageByIdx).length === 0
+                && !voiceoverSkipped.some((s) => s.reason === fatalImg.reason)) {
+                // Avoid double-warning when audio + image fail the same way.
+                console.warn(
+                    `[slice render] ⚠ images skipped — ${fatalImg.reason}` +
+                    (fatalImg.message ? `: ${fatalImg.message}` : '')
+                );
+            }
+        }
     }
 
     const serveUrl = resolveServeUrl();
-    const inputProps = buildInputProps(deck, { voiceoverByIdx });
+    const inputProps = buildInputProps(deck, { voiceoverByIdx, imageByIdx });
 
     // Lazy require so users who never run `slice render` don't pay the
     // remotion install cost at CLI startup (renderer pulls in puppeteer-
@@ -312,6 +352,8 @@ async function render(opts) {
         size: stat.size,
         voiceoverCount: Object.keys(voiceoverByIdx).length,
         voiceoverSkipped,
+        imageCount: Object.keys(imageByIdx).length,
+        imageSkipped,
     };
 }
 
@@ -319,15 +361,16 @@ async function handle(args) {
     const { parseFlag } = require('../core/args');
     const output = parseFlag(args, '--output', '-o');
     const noAudio = args.includes('--no-audio');
+    const noImages = args.includes('--no-images');
     const positional = args.find(
         (a) => !a.startsWith('-') && !a.startsWith('--')
     );
     if (!positional) {
-        console.error('Usage: voxflow slice render <deck.json> [--output out.mp4] [--no-audio]');
+        console.error('Usage: voxflow slice render <deck.json> [--output out.mp4] [--no-audio] [--no-images]');
         process.exit(1);
     }
     try {
-        await render({ deckPath: positional, output, noAudio });
+        await render({ deckPath: positional, output, noAudio, noImages });
     } catch (err) {
         console.error(`\nslice render failed: ${err.message}`);
         if (process.env.VOXFLOW_DEBUG) console.error(err.stack);

package/lib/commands/slice-stage.js

@@ -21,6 +21,7 @@ const { createSnapshotStore } = require('../stage-core/snapshot-store');
 const { createCloudRenderClient } = require('../stage-core/cloud-render');
 const { startLocalRender, getJobStatus } = require('../stage-core/local-render');
 const { createTtsAuditionClient } = require('../stage-core/tts-audition');
+const { createImageGenClient } = require('../stage-core/image-gen');
 const { validatePaperSlideDeck, isV2LayoutTreeDeck } = require('../internal/deck-validator');
 const { renderSliceStageHtml } = require('../stage-ui/slice/template');
 const { emit: emitTelemetry } = require('../core/telemetry');
@@ -221,6 +222,35 @@ async function startSliceStage(opts) {
     };
   })();
 
+  // ─── Image generation bridge (per-card 🎨 on stage UI) ────────────────
+  // Resolves `card.images[i]` against the live deck snapshot at request
+  // time. Image bytes are cached on disk by content hash so re-renders on
+  // the same (prompt, aspect, quality) cost zero quota after first gen.
+  const imagineBridge = opts.imagine || (() => {
+    const imgClient = opts.imageClient || createImageGenClient(opts.imageClientOpts || {});
+    return {
+      async play({ cardIndex, imageId }) {
+        if (!snapshot.deck) return { code: 'no_deck', message: 'no deck loaded' };
+        const cards = Array.isArray(snapshot.deck.cards) ? snapshot.deck.cards : [];
+        const card = cards[cardIndex];
+        if (!card) return { code: 'card_not_found', message: `no card at index ${cardIndex}` };
+        const images = Array.isArray(card.images) ? card.images : [];
+        const img = images.find((it) => it && it.id === imageId);
+        if (!img) {
+          return {
+            code: 'image_not_found',
+            message: `card ${cardIndex} has no image with id "${imageId}"`,
+          };
+        }
+        return imgClient.imagine({
+          prompt: img.prompt,
+          aspect: img.aspect,
+          quality: img.quality,
+        });
+      },
+    };
+  })();
+
   // Boot-time auth probe so the UI can emphasise local vs cloud render.
   // We treat any cached, non-expired token as "logged in"; the actual
   // request flow still revalidates on /api/quota-balance.
@@ -238,6 +268,7 @@ async function startSliceStage(opts) {
     localRender: localRenderBridge,
     deckSaver: deckSaverBridge,
     audition: auditionBridge,
+    imagine: imagineBridge,
     publishEvent: bus.publish,
     tokenAvailable,
     preferredPort,

package/lib/commands/slice.js

@@ -214,6 +214,13 @@ async function handle(args) {
         const sliceStage = require('./slice-stage');
         return sliceStage.handle(args.slice(1));
     }
+    // `voxflow slice fork <template-id>` — copy a curated template's
+    // deck.json into the user's cwd. No quota / network — assets ship in
+    // the published `skills/voxflow-slice/templates/` directory.
+    if (args.length > 0 && args[0] === 'fork') {
+        const sliceFork = require('./slice-fork');
+        return sliceFork.handle(args.slice(1));
+    }
 
     const { parseFlag, runWithRetry } = require('../core/args');
     const { getToken, getTokenInfo } = require('../core/auth');
@@ -330,6 +337,8 @@ const meta = {
             'voxflow slice stage deck.json                  # local preview, hot-reload',
             'voxflow slice stage deck.json --port 5180 --no-open',
             'voxflow slice render deck.json --output out.mp4  # offline render (no quota, no cloud)',
+            'voxflow slice fork --list                        # browse curated templates',
+            'voxflow slice fork product-launch                # copy a curated template to cwd',
         ],
     },
 };