ossclip 0.1.24 → 0.1.26

package/src/interactive/pick-save-path.ts

@@ -0,0 +1,214 @@
+import { readdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { expandHome } from "../paths";
+import { select, text, unwrap } from "./prompts";
+
+/**
+ * "Where should the video go?" — the output-file question, rebuilt as a
+ * folder walk (2026-08-16, the `~`-path incident's second defense). The raw
+ * text prompt this replaces is where `~/Downloads/x.mp4` got typed and — no
+ * shell expands a wizard text input (paths.ts) — resolved against cwd.
+ * expandHome now heals the typed form, but a picker removes the typing: the
+ * same navigate-a-listing interaction the editor's switch-project browser
+ * uses (ProjectPicker.tsx — folders only, hidden omitted, ".." to go up),
+ * rendered as a clack select loop.
+ *
+ * Same doctrine split as ask-input.ts: option shaping and filename
+ * normalization are pure and tested without a TTY; the loop takes an
+ * injectable prompts/fs seam shaped like thumbnail-approve's ApprovePrompts.
+ */
+
+export const SAVE_DEFAULT = "__save_default__";
+export const SAVE_HERE = "__save_here__";
+export const SAVE_UP = "__save_up__";
+export const SAVE_TYPE_PATH = "__save_type_path__";
+
+/** ~20 folders on screen; past that the escape hatch is typing the path. */
+export const FOLDER_CAP = 20;
+
+/** One readdir row, reduced to what the shaping rules need. */
+export interface DirEntry {
+  name: string;
+  isDir: boolean;
+}
+
+/**
+ * Directory entries → the select rows. Pure so the rules — folders only,
+ * hidden omitted, codepoint-sorted, capped at FOLDER_CAP with the type-a-path
+ * row as the overflow escape — are pinned without a filesystem.
+ *
+ * Folder row values are ABSOLUTE paths, not names: a folder could be named
+ * `__save_here__`, and a name-valued row would then collide with the
+ * sentinel. An absolute path never starts with `__`, so the dunder idiom
+ * (ask-input's BROWSE_FILE et al) stays collision-free.
+ */
+export function savePathOptions(
+  entries: DirEntry[],
+  opts: { dir: string; atRoot: boolean; defaultName?: string },
+): { value: string; label: string; hint?: string }[] {
+  const rows: { value: string; label: string; hint?: string }[] = [];
+  // The fast path: today's speed was "press Enter, get no --out". This row is
+  // that keystroke — offered only where produce's own default would land
+  // (the caller gates it to the input's folder).
+  if (opts.defaultName !== undefined) {
+    rows.push({
+      value: SAVE_DEFAULT,
+      label: `use default: ${opts.defaultName}`,
+      hint: "in this folder",
+    });
+  }
+  rows.push({ value: SAVE_HERE, label: "✓ save here", hint: "pick the file name next" });
+  if (!opts.atRoot) rows.push({ value: SAVE_UP, label: "↑ ..", hint: "up one folder" });
+
+  const folders = entries
+    .filter((e) => e.isDir && !e.name.startsWith("."))
+    .map((e) => e.name)
+    .sort();
+  for (const name of folders.slice(0, FOLDER_CAP)) {
+    rows.push({ value: join(opts.dir, name), label: `${name}/` });
+  }
+  const hidden = folders.length - FOLDER_CAP;
+  rows.push({
+    value: SAVE_TYPE_PATH,
+    label: "type a path instead",
+    hint: hidden > 0 ? `${hidden} more folders not shown` : "if you already know it",
+  });
+  return rows;
+}
+
+/**
+ * The typed file name, parsed not coerced: empty refused, a path separator
+ * refused (this prompt names a file IN the folder the walk just chose — a
+ * `sub/name` here would silently override that choice), and `.mp4` appended
+ * only when there is NO dot-extension at all. A typo'd `.mp5` stays and is
+ * the user's — "fixing" it is the exact coercion --source-fit's zod parse
+ * exists to prevent.
+ */
+export function normalizeOutName(
+  raw: string | undefined,
+): { ok: true; name: string } | { ok: false; problem: string } {
+  const name = (raw ?? "").trim();
+  if (name === "") return { ok: false, problem: "a file name is required" };
+  if (name.includes("/") || name.includes("\\")) {
+    return { ok: false, problem: "just the file name — the folder was picked above" };
+  }
+  return { ok: true, name: /\.[^.]+$/.test(name) ? name : `${name}.mp4` };
+}
+
+/**
+ * The seam, ApprovePrompts' shape (thumbnail-approve.ts): already unwrapped,
+ * never a cancel symbol, so the loop is drivable by a scripted object.
+ * `validate` rides through because the live re-ask-on-bad-input behavior is
+ * clack's; a scripted fake asserts its answers pass the same predicate.
+ */
+export interface SavePathPrompts {
+  select(opts: {
+    message: string;
+    options: { value: string; label: string; hint?: string }[];
+  }): Promise<string>;
+  text(opts: {
+    message: string;
+    initialValue?: string;
+    placeholder?: string;
+    validate?: (v: string | undefined) => string | undefined;
+  }): Promise<string>;
+}
+
+/** The live clack-backed prompts; tests inject a scripted replacement. */
+export function clackSavePathPrompts(): SavePathPrompts {
+  return {
+    select: async (opts) => unwrap(await select(opts)) as string,
+    text: async (opts) => unwrap(await text({ ...opts, defaultValue: "" })) as string,
+  };
+}
+
+/** The fs seam beside the prompts seam, so the walk is testable dry. */
+const liveListEntries = (dir: string): DirEntry[] => {
+  try {
+    return readdirSync(dir, { withFileTypes: true }).map((d) => ({
+      name: d.name,
+      isDir: d.isDirectory(),
+    }));
+  } catch {
+    // An unreadable folder (permissions, vanished between screens) lists as
+    // empty rather than crashing the wizard — "↑ .." and "type a path
+    // instead" remain on offer, which is every exit the user needs.
+    return [];
+  }
+};
+
+export interface PickSavePathArgs {
+  /**
+   * The input video's own folder: it is where creators keep a take's outputs,
+   * and it is where produce's flag-less default lands anyway — so the walk
+   * starts where the answer almost always is, and ~/Downloads is a few ".."
+   * and descents away when it isn't.
+   */
+  startDir: string;
+  /** `basename(defaultOutPath(input))` — the fast-path row's file name AND
+   * the file-name prompt's prefill, so plain Enter twice matches a flag-less
+   * run exactly. */
+  defaultName: string;
+  prompts?: SavePathPrompts;
+  listEntries?: (dir: string) => DirEntry[];
+}
+
+/**
+ * The walk. Returns the ABSOLUTE out path — or undefined for the use-default
+ * row, so the caller emits no --out at all: the picked file would equal
+ * produce's own default, and produceArgv's elision rule (a flag whose value
+ * equals the default is NEVER emitted) must survive the picker.
+ */
+export async function pickSavePath(args: PickSavePathArgs): Promise<string | undefined> {
+  const { prompts = clackSavePathPrompts(), listEntries = liveListEntries } = args;
+  const startDir = resolve(expandHome(args.startDir));
+  let dir = startDir;
+  for (;;) {
+    const options = savePathOptions(listEntries(dir), {
+      dir,
+      // `dirname` at the root returns the root itself, on every platform —
+      // the same fixed point the editor's browser keys its ".." row off.
+      atRoot: dirname(dir) === dir,
+      // The default row exists wherever the default would actually land —
+      // navigate away and it goes, come back and it returns.
+      defaultName: dir === startDir ? args.defaultName : undefined,
+    });
+    const choice = await prompts.select({ message: `Save the video where? — ${dir}`, options });
+
+    if (choice === SAVE_DEFAULT) return undefined;
+    if (choice === SAVE_UP) {
+      dir = dirname(dir);
+      continue;
+    }
+    if (choice === SAVE_TYPE_PATH) {
+      const typed = await prompts.text({
+        message: "Output file path",
+        placeholder: "~/Downloads/final.mp4",
+        validate: (v) => (v?.trim() ? undefined : "a path is required"),
+      });
+      // expandHome BEFORE resolve (2026-08-16 incident, paths.ts): a typed
+      // `~/Downloads/x.mp4` must become the home path, never `<cwd>/~/...`.
+      // resolve() then makes the emitted argv absolute, matching ask-input's
+      // expanded-argv behavior.
+      return resolve(expandHome(typed.trim()));
+    }
+    if (choice === SAVE_HERE) {
+      const name = await prompts.text({
+        message: "File name",
+        initialValue: args.defaultName,
+        validate: (v) => {
+          const r = normalizeOutName(v);
+          return r.ok ? undefined : r.problem;
+        },
+      });
+      const r = normalizeOutName(name);
+      // The live prompt re-asks through `validate`, so not-ok here means a
+      // scripted fake skipped its own predicate — re-asking is still what a
+      // real user would see, so loop rather than crash.
+      if (!r.ok) continue;
+      return join(dir, r.name);
+    }
+    // A folder row: its value is already the absolute path — descend.
+    dir = choice;
+  }
+}

package/src/interactive/produce-argv.ts

@@ -14,8 +14,11 @@ export interface ProduceExtras {
   speaker?: string;
   whisperModel?: string;
   whisperLanguage?: string;
+  // No `collapseRetakes` (2026-08-16): retake collapse runs automatically
+  // with --blooper-marker (inferredRetakesEnabled, produce.ts), so the
+  // wizard never emits the legacy --collapse-retakes flag — it survives only
+  // as a parseable no-op for recorded command.json replays.
   blooperMarker?: string;
-  collapseRetakes?: boolean;
   sourceIsEdited?: boolean;
   /** Opt-in "made with ossclip" credit. The wizard only ever turns it ON —
    * off is the default, and a config-on user who wants it off for one run
@@ -26,6 +29,27 @@ export interface ProduceExtras {
    * the positive `--captions` stays flags-only — it exists for replay
    * pinning, and emitting it here would restate the default. */
   captions?: boolean;
+  /** Jump-cut punch tri-state, captions' twin polarity: auto (unset) already
+   * punches face-only takes, so the wizard only ever turns it OFF (`false` →
+   * `--no-jump-cuts`) and the positive `--add-jump-cuts` stays flags-only —
+   * it exists to beat a future config-off, and emitting it here would
+   * restate the default. */
+  jumpCuts?: boolean;
+  /** The YouTube pack (Y2): the wizard only ever turns it ON — off is the
+   * default, and a config-on user who wants it off for one run types
+   * `--no-youtube`, flags-only like `--no-watermark`. */
+  youtube?: boolean;
+  /** Portrait photo path for the pack's AI thumbnail — the youtube entry's
+   * follow-up prompt; empty answers never reach here (the wizard skips the
+   * flag and the frame-grab cover stands). */
+  portrait?: string;
+  /** Who the channel is for — the youtube entry's first follow-up, skipped
+   * when the config's `audience` already answers it. Empty answers never
+   * reach here (default-elision: the config decides). */
+  audience?: string;
+  /** The durable thumbnail steer — the youtube entry's optional follow-up;
+   * empty answers never reach here, same elision as `audience`. */
+  thumbnailBrief?: string;
   /** core's ProviderName, not an inline union — a provider added there must
    * not be silently unofferable here (the pre-§132 union had already
    * drifted: it never listed "antigravity"). */
@@ -69,12 +93,25 @@ export function produceArgv(a: ProduceAnswers): string[] {
   // no flag whose value equals the default.
   if (e.whisperLanguage) argv.push("--whisper-language", e.whisperLanguage);
   if (e.blooperMarker) argv.push("--blooper-marker", e.blooperMarker);
-  if (e.collapseRetakes === true) argv.push("--collapse-retakes");
   if (e.sourceIsEdited === true) argv.push("--source-is-edited");
   if (e.watermark === true) argv.push("--watermark");
   // Strict `=== false` (never `!e.captions`): undefined means "the default,
   // on" and must emit nothing per the elision rule above.
   if (e.captions === false) argv.push("--no-captions");
+  // Same strict rule: only the wizard's OFF tick emits, and only the
+  // negative spelling — auto must stay an ABSENT flag, or the taught
+  // command line restates a default.
+  if (e.jumpCuts === false) argv.push("--no-jump-cuts");
+  // Watermark's shape: only the ON tick emits (off is the default, elided),
+  // and the portrait only rides along with a value — the wizard already
+  // dropped empty answers.
+  if (e.youtube === true) argv.push("--youtube");
+  // The youtube follow-ups ride only with a value, portrait's exact rule:
+  // the wizard already dropped empty answers, and an unset field means "the
+  // config decides" — emitting a bare flag would be a commander error.
+  if (e.audience) argv.push("--audience", e.audience);
+  if (e.portrait) argv.push("--portrait", e.portrait);
+  if (e.thumbnailBrief) argv.push("--thumbnail-brief", e.thumbnailBrief);
   if (e.llm) argv.push("--llm", e.llm);
 
   return argv;

package/src/interactive/produce-wizard.ts

@@ -1,19 +1,27 @@
-import { basename } from "node:path";
+import { basename, dirname, resolve } from "node:path";
 import { existsSync, readdirSync } from "node:fs";
+import { saveConfigPatch, type OssclipConfig } from "@ossclip/core";
+import { MODELS, bareWhisperModelName, modelImpliedLanguage } from "../setup/manifest";
+import { defaultOutPath } from "../produce";
+import { expandHome } from "../paths";
 import { askInput } from "./ask-input";
+import { pickSavePath } from "./pick-save-path";
 import { produceArgv, type ProduceAnswers, type ProduceExtras } from "./produce-argv";
 import { assertInteractive, confirm, intro, multiselect, select, text, unwrap } from "./prompts";
 
 /**
- * The produce wizard. Thirty-four flags (plus the positional input path)
+ * The produce wizard. Forty-one flags (plus the positional input path)
  * sorted into three tiers: six prompts asked directly — the input path, plus
- * five flags (--out, --cleanup, --aspect, --produce, --intent) — ten behind
- * one "anything else?" multiselect, and the remaining stay flags-only:
+ * five flags (--out, --cleanup, --aspect, --produce, --intent) — eleven
+ * behind one "anything else?" multiselect, and the remaining stay flags-only:
  * debug/internal surfaces, replay-only fields, --no-watermark (the
  * multiselect only turns the credit ON; off is already the default),
+ * --no-youtube (the same shape: the pack entry only turns it ON),
  * --captions (the mirror case: ON is already the default, so the
  * multiselect entry is the OFF switch and the positive flag exists only for
- * replay pinning), or
+ * replay pinning), --add-jump-cuts (same mirror: auto already punches, the
+ * multiselect entry is the OFF switch, and the force flag exists to beat a
+ * future config-off), or
  * (final-review fix wave, Finding 1) --sort. A folder's clip order only means anything once the
  * folder has been enumerated, and that enumeration happens inside
  * `produce()` — after the wizard has already returned argv — so there is
@@ -32,15 +40,23 @@ const EXTRAS = [
   { value: "sourceFit", label: "Show the whole frame instead of cropping", hint: "--source-fit contain" },
   { value: "speaker", label: "Say who is on camera", hint: "--speaker" },
   { value: "whisperModel", label: "Pick a transcription model", hint: "--whisper-model" },
+  // Retake collapse is deliberately NOT an entry (2026-08-16): it runs
+  // automatically with --blooper-marker and never otherwise
+  // (inferredRetakesEnabled, produce.ts), and the user asked for it not to
+  // be exposed as its own knob — the marker entry above IS the switch.
   { value: "blooperMarker", label: "Cut flubbed takes on a spoken word", hint: "--blooper-marker" },
-  {
-    value: "collapseRetakes",
-    label: "Collapse repeated takes automatically",
-    hint: "--collapse-retakes",
-  },
   { value: "sourceIsEdited", label: "Source already has burned-in text", hint: "--source-is-edited" },
   { value: "captionsOff", label: "Turn the burned-in captions off", hint: "--no-captions" },
+  { value: "jumpCutsOff", label: "No punch-in zooms at cuts", hint: "--no-jump-cuts" },
   { value: "watermark", label: 'Credit the tool with a small "made with ossclip"', hint: "--watermark" },
+  // The hint says the approval part out loud (thumbnail UX, 2026-08-16):
+  // ticking this adds an interactive stop before the render, and a surprise
+  // prompt mid-run reads as a hang to someone who didn't expect it.
+  {
+    value: "youtube",
+    label: "YouTube pack: SEO metadata + AI thumbnail",
+    hint: "--youtube · you approve the thumbnail concept before render",
+  },
   { value: "llm", label: "Choose the LLM provider", hint: "--llm" },
 ] as const;
 
@@ -74,22 +90,78 @@ export function extrasFor(
   );
 }
 
-/** Select value that routes to the free-text model prompt instead of a name. */
-export const CUSTOM_MODEL = "__custom__";
+/**
+ * Which follow-up prompts the youtube extra asks, given what the config
+ * already supplies — `watermarkFromConfig`'s gating idea applied to the
+ * follow-up tier: a question whose answer is already in
+ * ~/.ossclip/config.json is noise, not a prompt (the flag still overrides
+ * the config for a one-off; that is a typed-flags surface, not a wizard
+ * one). `typeof`+trim, not truthiness: config.json is hand-edited and
+ * unparsed, and a `"audience": true` typo must mean "still ask", never a
+ * skipped question over a bogus value. Pure so the gating matrix is
+ * testable without a TTY.
+ */
+export function youtubeFollowups(cfg: {
+  audience?: string;
+  portrait?: string;
+  thumbnailBrief?: string;
+}): Array<"audience" | "portrait" | "brief"> {
+  const asks: Array<"audience" | "portrait" | "brief"> = [];
+  if (typeof cfg.audience !== "string" || cfg.audience.trim() === "") asks.push("audience");
+  if (typeof cfg.portrait !== "string" || cfg.portrait.trim() === "") asks.push("portrait");
+  if (typeof cfg.thumbnailBrief !== "string" || cfg.thumbnailBrief.trim() === "") {
+    asks.push("brief");
+  }
+  return asks;
+}
 
 /**
- * A model pick reduced to its bare name: basename, minus the optional ggml-
- * prefix and .bin suffix. Exists because the language prefill classifies on
- * `.endsWith(".en")`, and an absolute path like /x/ggml-small.en.bin ends in
- * ".bin" — an English model would have been prefilled `auto` (review fix,
- * Urdu field test 2026-08-05).
+ * The config patch a yes to "remember these for future runs?" writes, or
+ * null when nothing was freshly typed — null means the offer never appears.
+ * Only answers TYPED into this run's follow-ups qualify: a key the config
+ * already supplies was never asked (youtubeFollowups gates the prompts on
+ * exactly that), and the same gate here keeps a future re-ask from letting a
+ * wizard answer silently clobber a hand-edited config.json. Portrait is
+ * stored as the expandHome-expanded absolute path — a `~` string in
+ * config.json would work today (produce.ts expands the config value too, see
+ * its own comment at the thumbnail step), but an absolute path in a
+ * hand-edited file is self-documenting about which home it meant. Pure, with
+ * `home` injectable like expandHome's own, so the matrix is testable without
+ * a TTY or the real homedir.
+ *
+ * Wizard-only by placement: flag-driven runs never reach this — power users
+ * have config, and an interactive prompt at the end of a scripted run would
+ * break the script.
  */
-export function bareWhisperModelName(nameOrPath: string): string {
-  const base = basename(nameOrPath);
-  const m = /^(?:ggml-)?(.+?)(?:\.bin)?$/.exec(base);
-  return m?.[1] ?? base;
+export function rememberPatch(
+  typed: { audience?: string; portrait?: string; thumbnailBrief?: string },
+  cfg: { audience?: string; portrait?: string; thumbnailBrief?: string },
+  home?: string,
+): Partial<OssclipConfig> | null {
+  const asked = new Set(youtubeFollowups(cfg));
+  // Same typeof+trim rule as youtubeFollowups: a whitespace answer was
+  // already dropped by the prompts, but a durable config write deserves the
+  // same parse-don't-coerce guard as the read side.
+  const fresh = (v: string | undefined): v is string =>
+    typeof v === "string" && v.trim() !== "";
+  const patch: Partial<OssclipConfig> = {};
+  if (asked.has("audience") && fresh(typed.audience)) patch.audience = typed.audience;
+  if (asked.has("portrait") && fresh(typed.portrait)) {
+    patch.portrait = resolve(expandHome(typed.portrait, home));
+  }
+  if (asked.has("brief") && fresh(typed.thumbnailBrief)) {
+    patch.thumbnailBrief = typed.thumbnailBrief;
+  }
+  return Object.keys(patch).length === 0 ? null : patch;
 }
 
+/** Select value that routes to the free-text model prompt instead of a name. */
+export const CUSTOM_MODEL = "__custom__";
+
+// Moved to the setup manifest (its language/URL tables need the same
+// stripping); re-exported so this module's callers and tests keep one home.
+export { bareWhisperModelName };
+
 /** The three names `ossclip setup` knows how to download, with their hints. */
 const CANONICAL_MODELS = [
   { value: "base.en", hint: "fastest, least accurate" },
@@ -123,8 +195,24 @@ export function whisperModelChoices(
     label: c.value,
     hint: installed.has(c.value) ? c.hint : `${c.hint} · will need download`,
   }));
-  const canonical = new Set<string>(CANONICAL_MODELS.map((c) => c.value));
-  for (const name of [...installed].filter((n) => !canonical.has(n)).sort()) {
+  // Curated fine-tunes (a manifest `url` marks one): listed like the
+  // canonicals whether or not downloaded — setup can fetch them now, so the
+  // wizard must be able to name them (the one-command experience the curated
+  // table exists for), with the provenance note as the hint.
+  const curated = Object.entries(MODELS).filter(
+    ([name, info]) => info.url !== undefined && !CANONICAL_MODELS.some((c) => c.value === name),
+  );
+  for (const [name, info] of curated) {
+    choices.push({
+      value: name,
+      label: name,
+      hint:
+        (info.note ?? "curated fine-tune") +
+        (installed.has(name) ? "" : " · will need download"),
+    });
+  }
+  const listed = new Set(choices.map((c) => c.value));
+  for (const name of [...installed].filter((n) => !listed.has(n)).sort()) {
     choices.push({ value: name, label: name, hint: "installed" });
   }
   choices.push({
@@ -135,8 +223,30 @@ export function whisperModelChoices(
   return choices;
 }
 
+/**
+ * The language follow-up's prefill for a picked model. The curated table's
+ * own language wins — `medium-urdu` prefills `ur`, so plain Enter runs the
+ * fine-tune with the code it was trained for instead of the `auto` detect
+ * gamble. Otherwise the standing heuristic: a non-.en pick is multilingual
+ * by construction, so `auto` lets whisper detect; `.en` keeps whisper's en
+ * default (empty = no flag, produceArgv's default-elision rule).
+ */
+export function whisperLanguagePrefill(model: string): string {
+  return modelImpliedLanguage(model) ?? (bareWhisperModelName(model).endsWith(".en") ? "" : "auto");
+}
+
 export async function produceWizard(
-  cfg: { speaker?: string; modelDir?: string; input?: string; watermark?: boolean } = {},
+  cfg: {
+    speaker?: string;
+    modelDir?: string;
+    input?: string;
+    watermark?: boolean;
+    /** Gate the youtube follow-ups (youtubeFollowups): ask only what the
+     * config doesn't already answer. */
+    audience?: string;
+    portrait?: string;
+    thumbnailBrief?: string;
+  } = {},
 ): Promise<string[]> {
   assertInteractive("produce wizard");
   intro("ossclip produce");
@@ -190,10 +300,18 @@ export async function produceWizard(
       ) as string)
     : undefined;
 
-  const defaultOut = `${basename(input).replace(/\.[^.]+$/, "")}.ossclip.mp4`;
-  const out = unwrap(
-    await text({ message: "Output file", placeholder: defaultOut, defaultValue: "" }),
-  ) as string;
+  // Folder walk instead of the raw text prompt (2026-08-16 `~`-path
+  // incident, pick-save-path.ts). The default name comes from produce's own
+  // `defaultOutPath`, not this file's old duplicate regex, so the fast-path
+  // row names exactly the file a flag-less run writes; picking that row
+  // returns undefined and the elision rule below emits no --out at all.
+  // Resolved first because a typed relative input must anchor the walk (and
+  // the default's folder) to cwd, not to wherever `dirname` lands.
+  const resolvedInput = resolve(input);
+  const out = await pickSavePath({
+    startDir: dirname(resolvedInput),
+    defaultName: basename(defaultOutPath(resolvedInput)),
+  });
 
   const chosen = unwrap(
     await multiselect({
@@ -221,12 +339,93 @@ export async function produceWizard(
     );
   }
   if (chosen.includes("sourceFit")) extras.sourceFit = "contain";
-  if (chosen.includes("collapseRetakes")) extras.collapseRetakes = true;
   if (chosen.includes("sourceIsEdited")) extras.sourceIsEdited = true;
   // The entry is the OFF switch (captions default ON — see EXTRAS), so a
   // tick maps to `captions: false` and produceArgv emits `--no-captions`.
   if (chosen.includes("captionsOff")) extras.captions = false;
+  // Same OFF-switch shape (the punch defaults ON, face-only): a tick maps
+  // to `jumpCuts: false` and produceArgv emits `--no-jump-cuts`.
+  if (chosen.includes("jumpCutsOff")) extras.jumpCuts = false;
   if (chosen.includes("watermark")) extras.watermark = true;
+  if (chosen.includes("youtube")) {
+    extras.youtube = true;
+    // Follow-ups under the same extra, like --clip's seconds prompt — but
+    // gated on the config (youtubeFollowups): a question whose answer is
+    // already in ~/.ossclip/config.json is never re-asked. All three trim,
+    // like the language follow-up: a whitespace answer must not become a
+    // bogus flag value, and an empty answer means "no flag" (the config, or
+    // nothing, decides).
+    const followups = youtubeFollowups(cfg);
+    if (followups.includes("audience")) {
+      const audience = (
+        unwrap(
+          await text({
+            message: "Who is this channel for?",
+            placeholder: "junior web devs learning AI tooling",
+            defaultValue: "",
+          }),
+        ) as string
+      ).trim();
+      if (audience) extras.audience = audience;
+    }
+    if (followups.includes("portrait")) {
+      // The portrait only means anything to the pack's AI thumbnail.
+      // Optional — empty skips the flag, and the thumbnail falls back to
+      // the frame-grab cover.
+      const portrait = (
+        unwrap(
+          await text({
+            message: "Portrait photo for the AI thumbnail (empty = use the frame-grab cover)",
+            placeholder: "~/Pictures/me.jpg",
+            defaultValue: "",
+          }),
+        ) as string
+      ).trim();
+      if (portrait) extras.portrait = portrait;
+    }
+    if (followups.includes("brief")) {
+      const brief = (
+        unwrap(
+          await text({
+            message: "Anything the thumbnail must get right? (optional)",
+            placeholder: "always show the terminal, never stock imagery",
+            defaultValue: "",
+          }),
+        ) as string
+      ).trim();
+      if (brief) extras.thumbnailBrief = brief;
+    }
+    // Offer to persist the fresh answers (UX completion, 2026-08-17): all
+    // three are durable channel facts, and before this the wizard re-asked
+    // them every run until the user hand-edited ~/.ossclip/config.json. The
+    // write is an ADDITION for the NEXT run (loadConfig picks it up), never a
+    // substitute for the flags: this run's argv below still carries the typed
+    // values, so the printed command stays replayable on a machine without
+    // the config. The decision itself lives in rememberPatch, tested without
+    // a TTY — this block is only the I/O around it, offer-editor's split.
+    const patch = rememberPatch(
+      {
+        audience: extras.audience,
+        portrait: extras.portrait,
+        thumbnailBrief: extras.thumbnailBrief,
+      },
+      cfg,
+    );
+    if (patch !== null) {
+      const remember = unwrap(
+        await confirm({
+          message: "Remember these for future runs? (saves to ~/.ossclip/config.json)",
+          initialValue: true,
+        }),
+      ) as boolean;
+      if (remember) {
+        const path = saveConfigPatch(patch);
+        // Say where the answers went — offer-editor's rule: a preference
+        // saved silently is one the user cannot find again to take back.
+        console.log(`▸ saved ${Object.keys(patch).join(", ")} to ${path}`);
+      }
+    }
+  }
   if (chosen.includes("speaker")) {
     extras.speaker = unwrap(
       await text({
@@ -268,16 +467,16 @@ export async function produceWizard(
     // Follow-up under the same extra, like --clip's seconds prompt: a language
     // only means anything once a model is being picked, and a multilingual
     // fine-tune silently decodes English without it (Urdu field test
-    // 2026-08-05). A non-.en pick is multilingual by construction, so the
-    // prefill makes plain Enter the safe answer — `auto` lets whisper detect.
-    // Empty keeps whisper's en default, and produceArgv's default-elision
-    // rule then emits no flag at all.
+    // 2026-08-05). The prefill (whisperLanguagePrefill) makes plain Enter the
+    // safe answer: a curated fine-tune's own language, else `auto` for a
+    // non-.en pick. Empty keeps whisper's en default, and produceArgv's
+    // default-elision rule then emits no flag at all.
     const lang = (
       unwrap(
         await text({
           message: "Transcription language code (empty = default en)",
           placeholder: "ur",
-          initialValue: bareWhisperModelName(model).endsWith(".en") ? "" : "auto",
+          initialValue: whisperLanguagePrefill(model),
           defaultValue: "",
         }),
       ) as string
@@ -312,7 +511,9 @@ export async function produceWizard(
     cleanup,
     graphics,
     intent,
-    out: out || undefined,
+    // Already `string | undefined`: pickSavePath's use-default row IS the
+    // old empty answer — no --out, produce derives its own default.
+    out,
     extras,
   });
 }