storyshot 0.1.3 → 0.3.1

package/README.md

@@ -15,6 +15,35 @@ second or two on screen.
 The agent plans, writes and fixes the storyboard. Storyshot does the
 recording and editing, and the same storyboard always renders the same video.
 
+## Next to similar tools
+
+Storyshot, [promo-video-recorder](https://github.com/palamut62/promo-video-recorder)
+and [demo-dev](https://www.npmjs.com/package/demo-dev) each made a promo of this
+repo's page, with the same storyline and free local voices only. The grid
+below is muted; open the full videos to hear them.
+
+https://github.com/user-attachments/assets/3d8175ab-ba15-4b61-961d-481e57566e7a
+
+<details>
+<summary>The three full videos, with sound</summary>
+
+**Storyshot**
+
+https://github.com/user-attachments/assets/22987356-2a74-4e28-9a14-a1b01d04f932
+
+**promo-video-recorder**
+
+https://github.com/user-attachments/assets/e5eb86e5-e69c-403b-ad6c-c4499592307a
+
+**demo-dev**
+
+https://github.com/user-attachments/assets/8d3370ca-7a90-48af-b1c9-88189763e95d
+
+</details>
+
+How each one was made, what we saw, and the caveats:
+[docs/comparison](docs/comparison/README.md).
+
 ## Quick start
 
 Open your project in Cursor or Claude Code and paste this into the agent chat:
@@ -51,8 +80,8 @@ macOS, Linux and Windows.
 
    ```
    Here's the plan. Reply "ok", or change any line:
-   1. Type: pitch: a 15–30 s promo
-   2. Length: about 15 s, 6 shots
+   1. Type: pitch: a promo for the landing page
+   2. Length: about 20 s, 6 shots
    3. Flow: hero → Examples → Try It → AI result → pricing → end card
    4. Voice: none (other options: free local English voice; ElevenLabs, key found in .env)
    5. Music: upbeat · Captions: English · Subtitle file (.srt): no
@@ -82,10 +111,13 @@ After your next release, re-render it and you have an up-to-date video.
 
 | ask for | type (`purpose`) | you get |
 |---|---|---|
-| a promo / launch / landing-page clip | `pitch` | 15–30 s, music, captions, tightly cut |
-| a how-to or onboarding video | `tutorial` | narrated, a spotlight on each click, numbered steps, soft music, `.srt` + chapters |
-| a lesson or explainer | `course` | narrated and explains the *why*, no music, `.srt` + chapters |
-| help-center snippets | `docs` | silent, one GIF per step |
+| a promo / launch / landing-page clip | `pitch` | short and tightly cut: intro card, the app in a browser frame, music, captions |
+| a how-to or onboarding video | `tutorial` | paced to follow along: one narrated action per step, the camera following each click, part cards, a second example, a recap; `.srt` + chapters |
+| a lesson or explainer | `course` | explains the *why*: concept cards, the idea shown in the app, question cards, a recap, no music; `.srt` + chapters |
+| help-center snippets | `docs` | silent per-step GIFs and PNGs cropped to the action, plus a ready-to-paste Markdown article |
+
+Length follows the purpose and the content, not a target: a promo is as short as
+its message, a tutorial as long as the workflow takes to explain.
 
 Any type can also be vertical (9:16) or in another language.
 
@@ -199,11 +231,19 @@ captionPosition: bottom                         # or top; can also be set per st
 purpose: pitch                                  # pitch | tutorial | course | docs (sets the defaults below)
 highlight: false                                # spotlight targets before click/type (per step or per action too)
 stepNumbers: false                              # numbered caption badges
-subtitles: false                                # write <out>.srt (narration, else captions)
+subtitles: false                                # write <out>.srt (narration, else captions); `burn` also burns the narration into the video, each word lighting up as it is spoken (captions move to the top)
+pace: slow                                      # fast (pitch) | normal (docs) | slow (tutorial, course): cursor and typing speed, a beat after each click, hold after narration, voice speed, how much of a wait is shown
+follow: true                                    # tutorial/course default: the camera zooms in on what each step touches and pans between steps (a step's own zoom wins; follow: false on a step skips it); or { scale: 1.8 }
+frame: true                                     # pitch default: the recording sits in a browser window on a backdrop; false = full frame, or { background: <css> }
 chapters: false                                 # write <out>.chapters.txt for YouTube
-clips: null                                     # gif | webm | mp4: one file per step in <out>-steps/
+clips: null                                     # gif | webm | mp4 | png, or a list (docs default: [gif, png]): one file per step in <out>-steps/, cropped to what the step touches, plus README.md, a ready-to-paste article (step captions, `doc:` text, images)
 maxWait: 1.0                                    # with duration: auto, the longest a wait is shown
 
+intro:                                          # optional title card before the recording (same fields as end_card)
+  title: Acme
+  subtitle: Ship **faster**
+  say: Meet Acme.
+
 setup:                                          # runs before recording starts
   - dismiss: { role: button, name: Accept cookies }
 
@@ -220,6 +260,11 @@ steps:
     sfx: riser                                        # rising sound + chime (or `chime`)
     actions:
       - waitFor: { text: Done, timeout: 120000 }      # waiting is compressed automatically
+  - card: { kicker: Part 2, title: Read the results }  # a section card before this step (tutorials); becomes a chapter
+    caption: The hits table
+    say: Each row is a protein similar to yours.
+    actions:
+      - mark: { css: "tbody tr:nth-child(1)" }
   - hidden: true                                      # cut, not shown in the video
     actions:
       - goto: /
@@ -260,6 +305,10 @@ You can add `exact: true`, `last: true` or `nth: 2` to any of them.
 | `scrollTo` | `scrollTo: { css: "#pricing", ms: 1200 }` |
 | `scroll` | `scroll: 600` |
 | `dismiss` | `dismiss: { role: button, name: Close }` (clicks only if visible) |
+| `mark` | `mark: "automatic zoom, captions"` sweeps a highlighter over that phrase, even inside a paragraph (scrolling to it if needed). `mark: { css: "table tr:nth-child(3)" }` marks any target with a box. Options: `ms` (sweep time, default 700), `color` (default: theme accent), `box: true/false`. Marks stay until the step ends. |
+| `unmark` | `unmark: true` clears the marks (and notes) earlier |
+| `note` | `note: { target: { label: Database }, text: Curated proteins only }` puts a short label with an arrow next to the element, on the side with the most room (or `side: left/right/top/bottom`). It stays until the step ends and gets reading time (about 3 words a second, or `ms`). |
+| `select` | `select: { target: { label: Database }, option: "UniProtKB/Swiss-Prot" }` picks an option in a dropdown (by its visible text, or part of it). `inspect` lists each dropdown's options. |
 
 `ms` sets how long the cursor takes to travel to the target (`dragMs` for each
 drag move). `highlight: true/false` on `click`, `type` or `move` overrides the
@@ -326,17 +375,28 @@ changed. Write names the way they should be pronounced (`say: P X Genius.`),
 and spell out prices (`eleven ninety-nine`) in `pronounce` or in the line itself. At normal pace that comes to
 about 2.5 words per second, or roughly 35 words for a 15 s video.
 
-### End card
+### Intro and end card
 
-Every field is optional; leave out `end_card` entirely for no end card.
+Every field is optional; leave out `intro` / `end_card` for none. A step's
+`card` takes the same fields and plays before that step (section titles in
+tutorials). Both are short
+animations: the logo pops in, the title rises, the `**bold**` highlight sweeps,
+and a `cta` that is a command (`npx …`, `npm …`, `pip …`, `brew …`, `curl …`)
+types itself out in a terminal pill. `init` writes an `intro` for promos;
+tutorials and lessons can add one (e.g. "How to export a report"), docs GIFs
+usually shouldn't.
 
 | field | meaning |
 |---|---|
 | `logo` | A target on the page (captured as an image, e.g. `{ alt: Acme logo }`) or a path to an image file. If the logo image already contains the wordmark, leave out `title`. |
 | `title` | Large product name next to the logo. |
+| `kicker` | Small label above the title, e.g. `Part 2`. |
 | `subtitle` | One line; `**bold**` gets an accent highlight. |
+| `image` | A picture or diagram file (png, jpg, svg) under the title: concept cards in lessons. |
+| `think` | Seconds to pause after the card's `say` (a question card), with a "Pause and think" countdown. The next step shows the answer. |
+| `bullets` | A numbered list that appears one item at a time: "what you'll learn" on an intro, a recap on the end card. The card stays up long enough to read it. |
 | `cta` | Dark call-to-action pill, e.g. `Start free at acme.com`. |
-| `duration` | Seconds (default 1.0). |
+| `duration` | Seconds. Default: fits the `say` line, else 1.0 (end card) or 2.2 (intro). |
 | `say` | Voiceover line played over the end card. |
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storyshot",
-  "version": "0.1.3",
+  "version": "0.3.1",
   "description": "Turn a short YAML storyboard into a polished product demo video of your web app — smooth cursor, auto zoom, captions, music.",
   "author": "boheling <boheling@gmail.com>",
   "repository": {

package/skills/storyshot/SKILL.md

@@ -55,9 +55,9 @@ everything.
 
    ```
    Here's the plan. Reply "ok", or change any line:
-   1. Type: pitch: a 15–30 s promo (other options: tutorial = narrated how-to;
-      course = narrated lesson; docs = silent step-by-step GIFs)
-   2. Length: about 15 s, 6 shots
+   1. Type: pitch: a promo for the landing page (other options: tutorial =
+      narrated how-to; course = narrated lesson; docs = silent step-by-step GIFs)
+   2. Length: about 20 s, 6 shots (it follows from the flow below)
    3. Flow: hero → Examples → Try It → AI result → pricing → end card
    4. Voice: none (other options: free local English voice; ElevenLabs, best
       quality and Chinese support, key found in .env)
@@ -67,14 +67,16 @@ everything.
       window for you to log in once; please use a demo account)
    ```
 
-   Defaults by type (propose these unless the request says otherwise):
+   Defaults by type (propose these unless the request says otherwise). There
+   is no target length: it follows from the purpose and the content. Estimate
+   it from the flow and say it in the plan, so the user can react.
 
-   | type | length | voice | music | on screen / files |
+   | type | length comes from | voice | music | on screen / files |
    |---|---|---|---|---|
-   | `pitch` | 15 s (or 30 s), 5–7 shots | optional | upbeat | captions |
-   | `tutorial` | 45–90 s, 6–12 steps | yes | soft | step numbers, spotlight, .srt, chapters |
-   | `course` | 1–3 min | yes | none | spotlight, .srt, chapters |
-   | `docs` | one GIF per step | none | none | step numbers, spotlight, GIFs |
+   | `pitch` | where it's shown and its one message: a landing-page loop or social clip is a handful of shots; a launch video can tell a longer story | optional | upbeat | captions, intro, frame |
+   | `tutorial` | every step of the workflow, each explained, plus a second example; as long as that takes | yes | soft | step numbers, spotlight, camera follows, part cards, recap, .srt, chapters |
+   | `course` | the concepts to teach: each idea, shown in the app, checked with a question | yes | none | spotlight, camera follows, concept and question cards, recap, .srt, chapters |
+   | `docs` | one clip per step, each just long enough to see its result | none | none | step numbers, spotlight, cropped GIFs + PNGs, README.md article |
 
    Captions match the site's language. `kokoro` (free, local) speaks English
    only; for other languages, use ElevenLabs.
@@ -121,12 +123,72 @@ everything.
 
 ## 3. Write the storyboard
 
-Rules of thumb from real renders:
+### Tutorials and lessons are not ads
+
+A promo shows as much as possible, fast. A tutorial does the opposite: the
+viewer has to be able to **do it themselves** afterwards, often in a technical
+or scientific tool they have never seen. Storyshot paces `tutorial` and
+`course` slowly by default (`pace: slow`: slower cursor and typing, a beat
+after every click, a hold after every narration line, slower voice, real
+progress shown for waits) and the camera follows the action (`follow`), so
+small controls are readable. Your job is the structure:
+
+- **Start with the goal**: an `intro` with `bullets` saying what the viewer
+  will be able to do ("Run a BLAST search", "Read the hits table", "Judge a
+  match by E-value"), and what they need beforehand.
+- **Split the workflow into parts**, each opened by a `card`
+  (`card: { kicker: Part 2, title: Read the results }` on its first step).
+  Cards become the YouTube chapters.
+- **One action per step.** Each click, field or choice is its own step with
+  its own `say:` explaining **what** it does and **why this value**. Never
+  "fill in the form and submit" in one line. `check` warns when a tutorial
+  step does more than two things.
+- **Show, then explain the result.** After an action that produces output
+  (a results table, a number, a plot, a status), add a step that only looks:
+  `mark` the value or row you're talking about (`mark: "E value"`,
+  `mark: { css: "tbody tr:nth-child(1)" }`), and say what it means and how to
+  judge it ("an E-value this small means the match is not by chance").
+- **Label the controls that matter.** `note: { target: …, text: "FASTA or accession" }`
+  puts a short callout with an arrow next to a field, button or column. Use it for
+  the one thing a newcomer would get wrong, not for everything.
+- **Dropdowns:** `select: { target: …, option: "…" }` (inspect lists the
+  options). Say why this option.
+- **Then a different example.** Run the workflow again with a second input
+  that behaves differently (another sequence, sample, parameter), and point
+  out what changed and why. Comparison is what makes the concept stick.
+  A short `card` ("Now a second example") separates it.
+- **Lessons (`course`) explain the why.** Use concept cards for ideas that
+  aren't on screen (`card: { kicker: Concept, title: …, bullets: […], image:
+  diagram.svg }`), and question cards before a reveal (`card: { kicker:
+  Question, title: "Which hit is the real homolog?", think: 3 }`, then the
+  next step marks the answer).
+- **Docs GIFs (`docs`)** become a help-center article: each step's clip is
+  cropped to what it touches and holds the result before looping; a PNG of
+  each result and `<out>-steps/README.md` are written too. Give every step a
+  short `caption` (the heading) and a `doc:` line (the article text), and
+  `note` the field the reader must not miss.
+- **End with a recap**: `end_card` with `bullets` listing the steps or rules
+  to remember, and a `say` that repeats them.
+- **Narrating real results.** You can't know the numbers (scores, counts,
+  E-values) before the app produces them. Write the result steps with
+  general narration, render once, read the actual values from the preview
+  frames, then rewrite those `say:`/`note`/caption lines with the real
+  numbers and run `compose` only (no re-recording, no new jobs).
+- **Waiting is part of the lesson.** Long computations are still compressed,
+  but say what is happening ("BLAST is now comparing your sequence against
+  the database; this usually takes under a minute").
+- Length follows the content. Don't cut explanation to hit a length, and
+  don't pad: if a part is long, split it into more parts rather than
+  speeding it up.
+
+Rules of thumb from real renders (promos and tutorials):
 
 - **One idea per step.**
-  - `pitch`: 1.5–3 s per step (`duration:`). A 15 s video is 5–7 visible
-    steps plus a 1–1.5 s `end_card`. Typical shape: hero → 2–4 steps of the
-    core flow ending on a visible result → pricing or CTA → end card.
+  - `pitch`: 1.5–3 s per step (`duration:`), so the viewer gets one beat per
+    shot; the number of shots comes from the story, plus a 1–1.5 s `end_card`. Typical shape: `intro` → hero → 2–4
+    steps of the core flow ending on a visible result → pricing or CTA → end
+    card. Promos sit in a browser window on a backdrop (`frame: false` turns
+    that off).
   - Other purposes: leave out `duration`. `auto` times each step to its
     narration and plays motion in real time.
 - **Captions ≤ 7 words.** `**bold**` the payoff ("Every text box is
@@ -148,6 +210,14 @@ Rules of thumb from real renders:
   and `press: "^"` send single keys. In `tutorial`/`course`, the spotlight
   highlights each click target automatically; add `highlight: true` to a
   `move` to point at something without clicking it.
+- **Point at what the narration names.** `mark: "the exact phrase"` sweeps a
+  highlighter over words on the page (or `mark: <target>` boxes a table row,
+  card or code line) while the voice says them. On text-heavy pages a mark
+  plus a zoom tells the viewer where to look.
+- **Static pages (a landing page, docs, a README) have nothing to click.**
+  Don't make a slideshow of scrolls: open with an `intro` (the promise),
+  `mark` the claims as they are spoken, zoom on 2–3 of them, and end on a
+  command or URL. If the product has a real flow, show that instead.
 - **Cut boring navigation** with a `hidden: true` step (e.g. `goto: /pricing`).
 - **Clean the frame** in `setup`: dismiss cookie banners, announcement bars and
   chat widgets. `dismiss` is a no-op when the element isn't there.

package/src/build.mjs

@@ -3,15 +3,16 @@ import { record } from './record.mjs';
 import { compose } from './compose.mjs';
 import { soundtrack } from './audio.mjs';
 import { measureVoice } from './voice.mjs';
-import { writeOutputs } from './outputs.mjs';
+import { writeOutputs, burnSubtitles } from './outputs.mjs';
 
 export async function build(cfg, mode = 'render', { log = console.log } = {}) {
   const t0 = Date.now();
   if (mode !== 'compose') await record(cfg, { log });
   if (mode === 'record') return { warnings: [] };
   const voiceLens = await measureVoice(cfg, { log });
-  const { silent, events, preview, warnings, captions, segs } = await compose(cfg, { log, voiceLens });
+  const { silent, events, preview, warnings, captions, cards, segs } = await compose(cfg, { log, voiceLens });
   const audio = await soundtrack(cfg, events, silent, { log });
-  const extras = await writeOutputs(cfg, { captions, segs, narration: audio.narration, total: events.total }, { log });
+  if (cfg.subtitles === 'burn') burnSubtitles(cfg, audio.narration ?? [], { log });
+  const extras = await writeOutputs(cfg, { captions, cards, segs, narration: audio.narration, total: events.total }, { log });
   return { out: audio.out, extras, preview, warnings: [...warnings, ...audio.warnings], duration: events.total, seconds: Math.round((Date.now() - t0) / 1000) };
 }

package/src/check.mjs

@@ -4,16 +4,17 @@ import YAML from 'yaml';
 import { loadConfig } from './config.mjs';
 import { gitIgnored } from './auth.mjs';
 
-const TOP = ['name', 'url', 'out', 'purpose', 'viewport', 'output', 'theme', 'music', 'voice', 'sfx', 'storageState', 'ignoreHTTPSErrors', 'colorScheme',
+const TOP = ['name', 'url', 'out', 'purpose', 'viewport', 'output', 'theme', 'music', 'voice', 'sfx', 'storageState', 'ignoreHTTPSErrors', 'intro', 'frame', 'pace', 'follow', 'colorScheme',
   'scrollOffset', 'captionPosition', 'highlight', 'stepNumbers', 'subtitles', 'chapters', 'clips', 'maxWait', 'setup', 'steps', 'end_card'];
-const STEP = ['caption', 'say', 'sayAt', 'duration', 'zoom', 'actions', 'hidden', 'sfx', 'highlight', 'captionPosition'];
+const STEP = ['caption', 'say', 'sayAt', 'duration', 'zoom', 'actions', 'hidden', 'sfx', 'highlight', 'captionPosition', 'card', 'follow', 'doc'];
 const ZOOM = ['target', 'scale', 'start', 'end', 'ramp', 'offset'];
-const END = ['logo', 'title', 'subtitle', 'cta', 'duration', 'say'];
+const END = ['logo', 'title', 'subtitle', 'cta', 'duration', 'say', 'kicker', 'bullets', 'image', 'think'];
 const TARGET = ['role', 'name', 'text', 'label', 'placeholder', 'alt', 'testId', 'css', 'exact', 'last', 'nth'];
-const OPTS = ['ms', 'offset', 'timeout', 'highlight'];
+const OPTS = ['ms', 'offset', 'timeout', 'highlight', 'color', 'box'];
 const ACTIONS = {
   pause: 'number', wait: 'number', move: 'target', hover: 'target', click: 'target', dismiss: 'target', waitFor: 'target',
   waitForUrl: 'string', networkIdle: 'any', goto: 'string', scrollTo: 'target', scroll: 'any', type: 'type', drag: 'drag', press: 'any',
+  mark: 'mark', unmark: 'any', note: 'note', select: 'select',
 };
 
 const dist = (a, b) => {
@@ -68,8 +69,22 @@ export function check(file, { draft = false } = {}) {
     if (s.hidden && (s.caption || s.say)) warnings.push(`${where}: hidden steps are cut from the video, so caption/say are ignored`);
     if (!Array.isArray(s.actions ?? [])) errors.push(`${where}: actions must be a list`);
     for (const [j, a] of (s.actions ?? []).entries()) checkAction(a, `${where} action ${j + 1}`);
+    if (s.card) unknown(s.card, END, `${where} card`);
+    // tutorials: one thing per step, so the viewer can follow (and the narration can explain it)
+    const purpose = raw.purpose ?? 'pitch';
+    if ((purpose === 'tutorial' || purpose === 'course') && !s.hidden) {
+      const doing = (s.actions ?? []).filter((a) => a && ['click', 'type', 'drag', 'press', 'goto', 'select'].includes(Object.keys(a)[0]) && !(Object.keys(a)[0] === 'press' && /^(Enter|Tab)$/.test(String(Object.values(a)[0]))));
+      if (doing.length > 2) warnings.push(`${where}: does ${doing.length} things (${doing.map((a) => Object.keys(a)[0]).join(', ')}) in one step — in a ${purpose}, split it so each action gets its own explanation and the viewer can keep up`);
+      if (doing.length && !s.say) warnings.push(`${where}: does something but has no say: line — in a ${purpose}, tell the viewer what and why`);
+      const kinds = (s.actions ?? []).map((a) => a && Object.keys(a)[0]);
+      if (s.say && kinds.some((k) => k === 'scroll' || k === 'scrollTo') && !kinds.some((k) => ['mark', 'note', 'click', 'type', 'select', 'move', 'hover'].includes(k)) && !s.zoom) {
+        warnings.push(`${where}: scrolls and talks but points at nothing — on a dense page the viewer can't tell what you mean; \`mark\` or \`note\` the row or value the narration is about (the camera then zooms to it)`);
+      }
+    }
   }
   if (raw.end_card) unknown(raw.end_card, END, 'end_card');
+  if (raw.intro) unknown(raw.intro, END, 'intro');
+  if (raw.frame && typeof raw.frame === 'object') unknown(raw.frame, ['background'], 'frame');
   const todo = (fs.readFileSync(file, 'utf8').split('\n').map((l, i) => [l.replace(/#.*$/, ''), i + 1]).filter(([l]) => /\bTODO\b/.test(l)));
   for (const [, n] of todo) errors.push(`line ${n}: replace the TODO placeholder`);
 
@@ -85,6 +100,16 @@ export function check(file, { draft = false } = {}) {
     if (type === 'number' && typeof v !== 'number') errors.push(`${where}: ${kind} takes milliseconds, e.g. "${kind}: 800"`);
     if (type === 'string' && typeof v !== 'string') errors.push(`${where}: ${kind} takes a string`);
     if (type === 'target') target(v, `${where} (${kind})`);
+    if (type === 'mark' && typeof v !== 'string') target(v, `${where} (mark)`); // a string is a phrase to highlight
+    if (type === 'select') {
+      if (!v?.target || v?.option == null) errors.push(`${where}: select needs { target: <dropdown>, option: "visible text of the option" }`);
+      else target(v.target, `${where} (select.target)`);
+    }
+    if (type === 'note') {
+      if (!v?.target || !v?.text) errors.push(`${where}: note needs { target: <target>, text: "short label" }`);
+      else { target(v.target, `${where} (note.target)`); unknown(v, ['target', 'text', 'side', 'ms', 'timeout'], `${where} (note)`); }
+      if (v?.side && !['auto', 'left', 'right', 'top', 'bottom'].includes(v.side)) errors.push(`${where}: note side must be auto, left, right, top or bottom`);
+    }
     if (type === 'type') {
       if (typeof v === 'string' || typeof v === 'number') return;
       if (v?.text == null) errors.push(`${where}: type needs text — "type: hello" types into the focused element, "type: { target: <target>, text: hello }" clicks the target first`);
@@ -104,7 +129,7 @@ export function check(file, { draft = false } = {}) {
   let summary = '';
   if (cfg) {
     const visible = cfg.steps.filter((s) => !s.hidden);
-    const says = visible.filter((s) => s.say).length + (cfg.endCard?.say ? 1 : 0);
+    const says = visible.filter((s) => s.say).length + (cfg.endCard?.say ? 1 : 0) + (cfg.intro?.say ? 1 : 0);
     if (cfg.voice && !says) warnings.push('voice is set but no step has a `say:` line');
     if (!cfg.voice && says) warnings.push('steps have `say:` lines but there is no `voice:` block, so they will not be spoken');
     if (!draft && cfg.voice && ['elevenlabs', 'openai'].includes(cfg.voice.provider)) {
@@ -126,7 +151,7 @@ export function check(file, { draft = false } = {}) {
     const fixed = visible.filter((s) => s.duration !== 'auto').reduce((a, s) => a + s.duration, 0);
     const auto = visible.filter((s) => s.duration === 'auto').length;
     const ec = cfg.endCard ? (cfg.endCard.duration === 'auto' ? null : cfg.endCard.duration) : 0;
-    const length = auto ? `${fixed ? `${fixed.toFixed(1)}s fixed + ` : ''}${auto} steps timed to narration${cfg.endCard ? ' + end card' : ''}`
+    const length = auto ? `${fixed ? `${fixed.toFixed(1)}s fixed + ` : ''}${auto} steps timed to narration${cfg.endCard ? ' + end card' : ''}${cfg.intro ? ' + intro' : ''}`
       : `${fixed.toFixed(1)}s of steps${cfg.endCard ? ` + ${ec ?? 'auto'}s end card` : ''}${ec != null ? ` = ${(fixed + ec).toFixed(1)}s total` : ''}`;
     summary = `${cfg.name}: purpose ${cfg.purpose}, ${visible.length} visible steps, ${length}` +
       (cfg.voice ? `, voice ${cfg.voice.provider}` : '') + ` → ${cfg.out}`;