npm - ossclip - Versions diffs - 0.1.35 → 0.1.37 - Mend

ossclip 0.1.35 → 0.1.37

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/README.md +11 -1
package/editor-dist/assets/index-pWbFr8vc.js +168 -0
package/editor-dist/index.html +1 -1
package/package.json +4 -4
package/src/analyze.ts +4 -0
package/src/cover.ts +18 -0
package/src/doctor.ts +38 -6
package/src/edit.ts +204 -34
package/src/interactive/produce-wizard.ts +13 -2
package/src/produce.ts +330 -45
package/src/program.ts +68 -0
package/src/setup/plan.ts +18 -0
package/src/whisper-backend.ts +103 -0
package/editor-dist/assets/index-DSB_SCmp.js +0 -166

package/editor-dist/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>ossclip editor</title>
-    <script type="module" crossorigin src="/assets/index-DSB_SCmp.js"></script>
+    <script type="module" crossorigin src="/assets/index-pWbFr8vc.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Bx2VQLP8.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "ossclip",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "description": "Local-first CLI video producer: cuts silence and fillers, word-timed captions, face-aware framing, and LLM-planned code-rendered graphics — transcription and rendering never leave your machine",
   "type": "module",
   "license": "MIT",
@@ -36,9 +36,9 @@
     "commander": "^12.1.0",
     "tsx": "^4.19.0",
     "zod": "^3.25.76",
-    "@ossclip/core": "0.1.35",
-    "@ossclip/renderer": "0.1.35",
-    "@ossclip/scenes": "0.1.35"
+    "@ossclip/renderer": "0.1.37",
+    "@ossclip/core": "0.1.37",
+    "@ossclip/scenes": "0.1.37"
   },
   "homepage": "https://github.com/AhsanAyaz/ossclip#readme",
   "bugs": {

package/src/analyze.ts CHANGED Viewed

@@ -117,6 +117,9 @@ export interface AnalyzeOptions {
   noiseDb?: number;
   whisperModel?: string;
   whisperLanguage?: string;
+  /** `--whisper-backend`, already zod-parsed by program.ts; undefined lets a
+   *  configured `whisperUrl` decide (resolveWhisperBackend in produce). */
+  whisperBackend?: "local" | "remote";
   blooperMarker?: string;
   collapseRetakes?: boolean;
   sort?: "name" | "mtime";
@@ -157,6 +160,7 @@ export async function runAnalyze(
     noiseDb: opts.noiseDb,
     whisperModel: opts.whisperModel,
     whisperLanguage: opts.whisperLanguage,
+    whisperBackend: opts.whisperBackend,
     blooperMarker: opts.blooperMarker,
     collapseRetakes: opts.collapseRetakes,
     sort: opts.sort,

package/src/cover.ts CHANGED Viewed

@@ -468,6 +468,24 @@ export function coverTextHold(args: {
         `(--cover-text-reset, or deleting ${COVER_PROVENANCE_BASENAME}, goes back to the generated one)`,
     };
   }
+  // The replay-render gap (field report 2026-08-31): a run without --produce
+  // generates NO headline, and letting that empty string win silently
+  // downgraded a banner cover to a bare frame on every render-from-the-
+  // editor. A persisted headline of ANY source outranks an empty generation
+  // — there is no fresher text to prefer. `reset` still goes bare: that is
+  // the user explicitly asking for the generated (here: no) headline.
+  if (
+    !args.reset &&
+    args.generated.trim() === "" &&
+    args.persisted !== null &&
+    args.persisted.text.trim() !== ""
+  ) {
+    return {
+      text: args.persisted.text,
+      textSource: args.persisted.textSource,
+      message: `▸ cover: keeping the previous headline "${args.persisted.text}" (this run generated none)`,
+    };
+  }
   return { text: args.generated, textSource: "beatsheet" };
 }

package/src/doctor.ts CHANGED Viewed

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import type { OssclipConfig } from "@ossclip/core";
 import { modelUrl, validModelSources, whisperModelPath } from "./setup/manifest";
+import { WHISPER_API_KEY_ENV, resolveWhisperBackend } from "./whisper-backend";
 /**
  * `ossclip doctor` (R18 §90a): check every prerequisite and print the exact
@@ -106,12 +107,23 @@ export async function runDoctor(cfg: OssclipConfig, p: DoctorProbes): Promise<Do
         }),
   });
+  // Remote transcription (2026-09-01 weak-CPU field report) makes the next
+  // two checks OPTIONAL rather than blocking: a machine that transcribes on
+  // Groq has no reason to own whisper.cpp or a 1.5 GB model, and doctor
+  // reporting two red lines on a working install is how a user concludes the
+  // tool is broken. The LLM-provider posture, one level up: pass with a
+  // detail that says why nothing is needed.
+  const remote = resolveWhisperBackend(undefined, cfg, p.env);
+  const remoteBackend = remote.ok && remote.backend.kind === "remote" ? remote.backend : null;
+  const notNeeded = (found: string): string =>
+    `${found} not found — not needed: remote transcription configured`;
   const whisperOk = await p.binRuns(cfg.whisperPath, "--help");
   checks.push({
     name: "whisper-cli",
-    ok: whisperOk,
-    detail: cfg.whisperPath,
-    ...(whisperOk
+    ok: whisperOk || remoteBackend !== null,
+    detail: whisperOk ? cfg.whisperPath : remoteBackend !== null ? notNeeded(cfg.whisperPath) : cfg.whisperPath,
+    ...(whisperOk || remoteBackend !== null
       ? {}
       : {
           fix: viaSetup(
@@ -134,9 +146,9 @@ export async function runDoctor(cfg: OssclipConfig, p: DoctorProbes): Promise<Do
   const modelOk = p.exists(modelPath);
   checks.push({
     name: `whisper model (${cfg.model})`,
-    ok: modelOk,
-    detail: modelPath,
-    ...(modelOk
+    ok: modelOk || remoteBackend !== null,
+    detail: modelOk ? modelPath : remoteBackend !== null ? notNeeded(modelPath) : modelPath,
+    ...(modelOk || remoteBackend !== null
       ? {}
       : {
           fix: viaSetup(
@@ -146,6 +158,26 @@ export async function runDoctor(cfg: OssclipConfig, p: DoctorProbes): Promise<Do
         }),
   });
+  // NO network call, unlike every other backend doctor could probe: a
+  // transcription request costs the user's metered free tier, and `doctor` is
+  // run repeatedly while fixing something else. This line reports the
+  // CONFIGURATION — the three things a 401 or a 404 would be about — and the
+  // provider's own status hints name the rest when a real run happens.
+  // Omitted entirely when remote is not configured: the local install is the
+  // default, and an extra "not configured" line for an opt-in feature is
+  // noise on every other machine.
+  if (remoteBackend !== null) {
+    checks.push({
+      name: "remote transcription",
+      ok: true,
+      detail:
+        `${remoteBackend.baseUrl} · model ${remoteBackend.model} · ` +
+        (remoteBackend.apiKey !== undefined
+          ? `${WHISPER_API_KEY_ENV} set`
+          : `no API key (fine for self-hosted; Groq needs ${WHISPER_API_KEY_ENV})`),
+    });
+  }
   // Provider, in the same order auto-detection uses (agy → claude CLI →
   // gemini key → anthropic key): subscription CLIs beat ambient env keys
   // since 2026-08 — a logged-in CLI is an explicit, already-paid choice

package/src/edit.ts CHANGED Viewed

@@ -4,7 +4,7 @@ import { createReadStream, existsSync, readFileSync, statSync } from "node:fs";
 import { copyFile, mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 import { homedir } from "node:os";
-import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "zod/v4";
 import {
@@ -56,12 +56,25 @@ import {
   // Resolved here too, not just in produce: an editor that offered stock sounds
   // the config excludes would let a user pick one the next render drops.
   resolveSfxBundledPack,
+  // The Color panel's .cube menu (2026-08-30): the same loader produce's LUT
+  // bake resolves against, the loadSfxLibrary rule for grades.
+  loadLutLibrary,
+  // …and the validator every grade layer goes through — the /api/luts payload
+  // carries the CONFIG grade so the panel can label its "Default" entry, and
+  // a malformed config value must read as "no default" there exactly as it
+  // reads in produce (`resolveProductionColorGrade` falls through to off).
+  resolveColorGrade,
   outInsideInputFolderMessage,
   outPathInsideInput,
   PORTRAIT_MIME_TYPES,
   portraitMimeType,
   readCoverProvenance,
   runWhisper,
+  // The remote transcription backend (2026-09-01) — the span re-decode goes
+  // through it whenever `whisperUrl` is configured.
+  createOpenAiCompatibleProvider,
+  type TranscribeRequest,
+  type Transcript,
   SegmentSchema,
   spliceTranscript,
   TranscriptSchema,
@@ -108,6 +121,7 @@ import { expandHome } from "./paths";
 // produce all resolve through — a second copy here would send a user to a
 // model file the rest of the tool never looks for.
 import { modelImpliedLanguage, whisperModelPath } from "./setup/manifest";
+import { resolveWhisperBackend } from "./whisper-backend";
 import {
   PORTRAIT_OVERRIDE_BASENAME,
   portraitExtensionForMime,
@@ -119,6 +133,7 @@ import { lastFlagValue, thumbnailPanelState } from "./thumbnail-panel";
 import { captionRegenProvider } from "./caption-regen-panel";
 import { binOnPath } from "./llm-detect";
 import {
+  YOUTUBE_PRIVACIES,
   attachDeliveryMedia,
   buildPublishPosts,
   publishConfigured,
@@ -189,6 +204,37 @@ export interface RetranscribeConfig {
   modelDir?: string;
   language?: unknown;
   dictionary?: unknown;
+  /** The remote-backend pair (2026-09-01): a configured URL means this span
+   *  is decoded by an OpenAI-compatible server instead of whisper.cpp, so the
+   *  server must see the same two keys `resolveWhisperBackend` reads. */
+  whisperUrl?: string;
+  whisperRemoteModel?: string;
+}
+/**
+ * The half of a range re-decode that is the same on BOTH backends: the
+ * decoder bias. Extracted (2026-09-01) so the remote path shares these rules
+ * verbatim instead of growing a second copy that drifts — the validation is
+ * the load-bearing part, and it is unchanged from the local-only version.
+ */
+function retranscribeBias(cfg: RetranscribeConfig): { language?: string; prompt?: string } {
+  const dict = Array.isArray(cfg.dictionary)
+    && cfg.dictionary.length > 0
+    && cfg.dictionary.every((t) => typeof t === "string" && t.trim().length > 0)
+    ? (cfg.dictionary as string[]).map((t) => t.trim())
+    : [];
+  // `cfg.model` can be absent on the remote backend (a machine that never
+  // installed a local model), and no model name implies no language.
+  const language = typeof cfg.language === "string" && cfg.language.trim().length > 0
+    ? cfg.language.trim()
+    : cfg.model !== undefined
+      ? modelImpliedLanguage(cfg.model)
+      : undefined;
+  const prompt = whisperPromptFor(dict);
+  return {
+    ...(language !== undefined ? { language } : {}),
+    ...(prompt !== undefined ? { prompt } : {}),
+  };
 }
 /**
@@ -229,21 +275,38 @@ export function retranscribeSettings(
         "then `ossclip setup` to install it.",
     };
   }
-  const dict = Array.isArray(cfg.dictionary)
-    && cfg.dictionary.length > 0
-    && cfg.dictionary.every((t) => typeof t === "string" && t.trim().length > 0)
-    ? (cfg.dictionary as string[]).map((t) => t.trim())
-    : [];
-  const language = typeof cfg.language === "string" && cfg.language.trim().length > 0
-    ? cfg.language.trim()
-    : modelImpliedLanguage(cfg.model);
-  const prompt = whisperPromptFor(dict);
   return {
     tools: { ffmpegPath: cfg.ffmpegPath, ffprobePath: cfg.ffprobePath },
     whisperPath: cfg.whisperPath,
     modelPath: whisperModelPath(cfg.model, cfg.modelDir),
-    ...(language !== undefined ? { language } : {}),
-    ...(prompt !== undefined ? { prompt } : {}),
+    ...retranscribeBias(cfg),
+  };
+}
+/**
+ * The same thing for the REMOTE backend (2026-09-01): no whisper binary and
+ * no model file, because the point of remote is that neither is installed —
+ * but ffmpeg still is, since the span is sliced out of `audio.wav` locally
+ * before it is uploaded.
+ *
+ * Pure, like its local twin: the whole "remote configured but ffmpeg isn't"
+ * corner is testable without a network.
+ */
+export function retranscribeRemoteSettings(
+  cfg: RetranscribeConfig,
+):
+  | { tools: { ffmpegPath: string; ffprobePath: string }; language?: string; prompt?: string }
+  | { error: string } {
+  if (!cfg.ffmpegPath || !cfg.ffprobePath) {
+    return {
+      error:
+        "ffmpeg is not configured — run `ossclip doctor` to see what is missing, " +
+        "then `ossclip setup` to install it. (Remote transcription still slices the span locally.)",
+    };
+  }
+  return {
+    tools: { ffmpegPath: cfg.ffmpegPath, ffprobePath: cfg.ffprobePath },
+    ...retranscribeBias(cfg),
   };
 }
@@ -436,6 +499,10 @@ export async function startEditServer(
        * `unknown` because it is file-only and typed at the consumer
        * (`resolveSfxBundledPack`), the `audience` rule. */
       sfxBundledPack?: unknown;
+      /** The config-level default grade the Color panel's "Default" entry
+       * names — `unknown` because it is file-only and typed at the consumer
+       * (`resolveColorGrade`), the `sfxBundledPack` rule. */
+      colorGrade?: unknown;
     } & RetranscribeConfig;
     /** Env seam for the publish endpoints — tests inject their own so the
      * runner's real OSSCLIP_POSTIZ_API_KEY (or its absence) never decides a
@@ -471,6 +538,13 @@ export async function startEditServer(
      */
     sliceAudio?: typeof extractAudioSpan;
     runWhisper?: typeof runWhisper;
+    /**
+     * The remote backend's half of the `runWhisper` seam (2026-09-01): with a
+     * `whisperUrl` configured the span goes to an OpenAI-compatible server
+     * instead of whisper.cpp, and a test must be able to observe that —
+     * including the failure sentence — without a network or an API key.
+     */
+    transcribeRemote?: (wavPath: string, req: TranscribeRequest) => Promise<Transcript>;
     /**
      * The sound library the SFX routes serve (`loadCfg`'s rule applied to the
      * pack loader): tests inject a hand-written library over a tmp dir, so the
@@ -481,6 +555,10 @@ export async function startEditServer(
      * loader rather than only that the routes serve what they were handed.
      */
     loadSfx?: typeof loadSfxLibrary;
+    /** The LUT library `/api/luts` serves — the `loadSfx` seam for grades:
+     * tests inject a hand-written library instead of depending on whatever
+     * the developer keeps in ~/.ossclip/luts. */
+    loadLuts?: typeof loadLutLibrary;
   } = {},
 ): Promise<EditServer> {
   // MUTABLE since R17 §83: the server can start with no project (the page
@@ -938,17 +1016,67 @@ export async function startEditServer(
                 error: "this workdir has no transcript.json to re-stamp — re-run `ossclip produce`.",
               });
             }
-            const settings = retranscribeSettings((opts.loadCfg ?? loadConfig)());
-            if ("error" in settings) return send(200, { ok: false, error: settings.error });
-            if (!existsSync(settings.modelPath)) {
-              // The `--transcript`-only install: whisper was never needed to
-              // make this project, so say what to run rather than 500ing.
-              return send(200, {
-                ok: false,
-                error:
-                  `whisper model not found at ${settings.modelPath} — run \`ossclip setup\` ` +
-                  `to download it.`,
+            const cfg = (opts.loadCfg ?? loadConfig)();
+            // Which engine re-decodes the span, resolved HERE rather than in
+            // retranscribeSettings (2026-09-01): the flag is a CLI thing and
+            // there is no CLI in this loop, so a configured `whisperUrl` is
+            // the whole switch. `undefined` as the flag can only answer ok —
+            // only an explicit `--whisper-backend remote` with nothing
+            // configured fails — so this is a narrowing, not a live branch.
+            const backendPick = resolveWhisperBackend(undefined, cfg, process.env);
+            if (!backendPick.ok) return send(200, { ok: false, error: backendPick.message });
+            const backend = backendPick.backend;
+            // One plan, two shapes: the local one needs a binary and a model
+            // file on disk, the remote one needs neither. Both need ffmpeg —
+            // the span is always sliced here.
+            let plan: {
+              tools: { ffmpegPath: string; ffprobePath: string };
+              language?: string;
+              prompt?: string;
+              decode: (wavPath: string, req: TranscribeRequest) => Promise<Transcript>;
+            };
+            if (backend.kind === "remote") {
+              const settings = retranscribeRemoteSettings(cfg);
+              if ("error" in settings) return send(200, { ok: false, error: settings.error });
+              const provider = createOpenAiCompatibleProvider({
+                baseUrl: backend.baseUrl,
+                model: backend.model,
+                ...(backend.apiKey !== undefined ? { apiKey: backend.apiKey } : {}),
               });
+              plan = {
+                ...settings,
+                // Uploaded AS-IS, no opus sidecar (produce's rule does not
+                // apply): a span is seconds long, so its wav is far under any
+                // upload cap and the encode would cost more than it saves.
+                decode: opts.transcribeRemote ?? ((wavPath, r) => provider.transcribe(wavPath, r)),
+              };
+            } else {
+              const settings = retranscribeSettings(cfg);
+              if ("error" in settings) return send(200, { ok: false, error: settings.error });
+              if (!existsSync(settings.modelPath)) {
+                // The `--transcript`-only install: whisper was never needed to
+                // make this project, so say what to run rather than 500ing.
+                return send(200, {
+                  ok: false,
+                  error:
+                    `whisper model not found at ${settings.modelPath} — run \`ossclip setup\` ` +
+                    `to download it.`,
+                });
+              }
+              plan = {
+                ...settings,
+                decode: (wavPath, r) =>
+                  (opts.runWhisper ?? runWhisper)(
+                    {
+                      whisperPath: settings.whisperPath,
+                      modelPath: settings.modelPath,
+                      outBase,
+                      ...(r.language !== undefined ? { language: r.language } : {}),
+                      ...(r.prompt !== undefined ? { prompt: r.prompt } : {}),
+                    },
+                    wavPath,
+                  ),
+              };
             }
             // Parsed, not cast: this file is about to be rewritten, and a
             // truncated one must fail loudly here rather than become the new
@@ -968,22 +1096,16 @@ export async function startEditServer(
               });
             }
             await (opts.sliceAudio ?? extractAudioSpan)(
-              settings.tools,
+              plan.tools,
               audio,
               tmpWav,
               srcIn,
               srcOut - srcIn,
             );
-            const fresh = await (opts.runWhisper ?? runWhisper)(
-              {
-                whisperPath: settings.whisperPath,
-                modelPath: settings.modelPath,
-                outBase,
-                ...(settings.language !== undefined ? { language: settings.language } : {}),
-                ...(settings.prompt !== undefined ? { prompt: settings.prompt } : {}),
-              },
-              tmpWav,
-            );
+            const fresh = await plan.decode(tmpWav, {
+              ...(plan.language !== undefined ? { language: plan.language } : {}),
+              ...(plan.prompt !== undefined ? { prompt: plan.prompt } : {}),
+            });
             const restamped = alignRestamp(
               transcript.words.slice(range.from, range.to),
               fresh.words,
@@ -1971,6 +2093,14 @@ export async function startEditServer(
               // What uploads (the CLI's --delivery): auto (default) builds
               // the cached delivery encode, master sends the untouched render.
               delivery: z.enum(["auto", "master"]).optional(),
+              // YouTube's privacy status (the CLI's --youtube-privacy),
+              // spelled ONCE — the flag's own value list, so the panel and
+              // the CLI can never accept different words. Absent leaves
+              // buildPostsPayload's safe private default alone: until this
+              // rode along, every panel publish landed private with no way
+              // to say otherwise, and two videos the user believed were
+              // published sat private on the channel (2026-08-29).
+              youtubePrivacy: z.enum(YOUTUBE_PRIVACIES).optional(),
             })
             .safeParse(JSON.parse(Buffer.concat(chunks).toString() || "{}"));
           if (!parsed.success) return send(400, { error: parsed.error.message });
@@ -2077,7 +2207,14 @@ export async function startEditServer(
               }
               capGroups = sizeCapGroups(picked);
             }
-            const posts = buildPublishPosts(pack, picked).map((p) => ({
+            // Same options object the CLI's publish path passes — undefined
+            // stays undefined so buildPostsPayload's safe private default is
+            // still the ONE place that decides an absent privacy.
+            const posts = buildPublishPosts(pack, picked, {
+              ...(parsed.data.youtubePrivacy !== undefined
+                ? { youtubePrivacy: parsed.data.youtubePrivacy }
+                : {}),
+            }).map((p) => ({
               ...p,
               caption: parsed.data.captions?.[p.target.id] ?? p.caption,
             }));
@@ -2624,6 +2761,39 @@ export async function startEditServer(
           });
         }
+        if (url.pathname === "/api/luts" && req.method === "GET") {
+          // The Color panel's .cube menu plus the config-level default grade.
+          // NO workdir guard, /api/sfx/library's rule: both halves are
+          // machine-global (~/.ossclip/luts and config.json), so the panel can
+          // build its dropdown before a project is open. Read per request like
+          // every other loadCfg consumer — a LUT dropped while the editor is
+          // up appears on the next refresh, not on a restart.
+          const library = (opts.loadLuts ?? loadLutLibrary)();
+          // The config grade rides along VALIDATED, not raw: a malformed
+          // config value is what produce ignores (`resolveProductionColorGrade`
+          // warns and proceeds without it), so a "Default (…)" entry built
+          // from it would offer an inherit that renders as nothing. Null means
+          // the panel shows no Default entry, and the warning is dropped for
+          // the sfxLibrary helper's reason — no console here, produce prints
+          // it on the run that grades.
+          const configGrade = resolveColorGrade(
+            (opts.loadCfg ?? loadConfig)().colorGrade,
+            "config",
+          ).grade;
+          return send(200, {
+            // METADATA only, the sfx library rule: the absolute `path` stays
+            // server-side. `file` (the basename, extension and all) is what an
+            // editor-written override must carry — `ColorGrade.lut` documents
+            // the basename, produce joins it against ~/.ossclip/luts verbatim,
+            // and a stem-only id would drop the `.CUBE` an exporter spelled.
+            items: library.items.map((l) => ({ id: l.id, title: l.title, file: basename(l.path) })),
+            // A ~/.ossclip/luts author's only surface, like the sfx panel:
+            // the loader degraded instead of throwing, so show the reason.
+            issues: library.issues,
+            configGrade: configGrade ?? null,
+          });
+        }
         if (url.pathname === "/api/sfx/audio" && req.method === "GET") {
           // Click-to-preview. The path comes from the LOADED LIBRARY, never
           // from the client: the query carries an id, the id is looked up, and

package/src/interactive/produce-wizard.ts CHANGED Viewed

@@ -10,7 +10,7 @@ import { produceArgv, type ProduceAnswers, type ProduceExtras } from "./produce-
 import { assertInteractive, confirm, intro, multiselect, select, text, unwrap } from "./prompts";
 /**
- * The produce wizard. Forty-one flags (plus the positional input path)
+ * The produce wizard. Forty-four 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) — twelve
  * behind one "anything else?" multiselect (--sfx being the twelfth, with
@@ -18,11 +18,22 @@ import { assertInteractive, confirm, intro, multiselect, select, text, unwrap }
  * 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),
+ * --color-grade (2026-08-30, the --resolution shape: a channel's look is a
+ * durable machine preference, set once as `colorGrade` in
+ * ~/.ossclip/config.json rather than re-picked per wizard run — and an
+ * honest prompt would need to enumerate ~/.ossclip/luts and preview five
+ * presets, a design nobody has made; --no-color-grade then mirrors
+ * --no-watermark's tier for the same off-is-default reason),
  * --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), --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
+ * future config-off),
+ * --whisper-backend (2026-09-01, the --color-grade shape: it selects machine
+ * INFRASTRUCTURE — which transcription engine this box owns, alongside
+ * whisperPath and modelDir — not a per-run editorial choice, and the durable
+ * spelling is `whisperUrl` in ~/.ossclip/config.json; an honest prompt would
+ * also have to explain a base URL and an API key at a menu), 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