blitzreels 0.1.3 → 0.1.4

package/dist/index.js

@@ -3,448 +3,18 @@ import { spawn } from "node:child_process";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, extname, join, resolve } from "node:path";
-import { BlitzReelsClient, BlitzReelsError, } from "@blitzreels/sdk";
-const CONFIG_PATH = join(homedir(), ".blitzreels", "config.json");
-const KEYCHAIN_SERVICE = "BlitzReels CLI";
-const KEYCHAIN_ACCOUNT = "api-key";
+import { BlitzReelsError } from "@blitzreels/sdk";
+import { CLI_VERSION, createCliClient, DEFAULT_BASE_URL, loadConfig, persistLoggedInApiKey, resolveRuntimeConfig, storeApiKey, } from "./cli-runtime.js";
+import { commandLabel, commandsEqual, flagsForCommand, GLOBAL_FLAGS, suggestCommandSpecs, suggestValues, } from "./command-metadata.js";
+import { COMMAND_SPECS } from "./command-registry.js";
+import { handleExportsCommand } from "./commands/exports.js";
+import { handleProjectsCommand } from "./commands/projects.js";
+import { buildDryRunRequest, requireDeleteConfirmation, requirePreviewFirstConfirmation, } from "./preview-first-edit.js";
+const UPDATE_CACHE_PATH = join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "blitzreels", "update-check.json");
+const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+const UPDATE_CHECK_TIMEOUT_MS = 800;
 const DEFAULT_WAIT_INTERVAL_MS = 3000;
 const DEFAULT_WAIT_TIMEOUT_MS = 20 * 60 * 1000;
-const GLOBAL_FLAGS = ["api-key", "base-url", "json", "help"];
-const TEXT_STYLE_FLAGS = [
-    "spec-json",
-    "font-family",
-    "font-size",
-    "font-weight",
-    "color",
-    "background-color",
-    "padding-x",
-    "padding-y",
-    "border-radius",
-    "top",
-    "left",
-    "text-align",
-    "text-shadow",
-    "no-background",
-];
-const CAPTION_WORD_SELECTOR_FLAGS = [
-    "word-id",
-    "word-ids",
-    "timeline-item-id",
-    "match-text",
-    "match-pattern",
-];
-const CAPTION_WORD_STYLE_FLAGS = [
-    "style-json",
-    "font-family",
-    "font-weight",
-    "font-style",
-    "color",
-    "active-color",
-    "background-color",
-    "active-animation",
-    "text-transform",
-    "text-shadow",
-    "glow-color",
-    "glow-blur-px",
-    "scale",
-    "offset-x",
-    "offset-y",
-    "rotation-deg",
-    "letter-spacing",
-    "opacity",
-    "clear-existing",
-];
-function commandSpec({ command, usage, flags = [], }) {
-    return { command, usage, flags };
-}
-const COMMAND_SPECS = [
-    commandSpec({
-        command: ["auth", "login"],
-        usage: "blitzreels auth login [--no-browser] [--timeout-ms 120000]",
-        flags: ["no-browser", "timeout-ms"],
-    }),
-    commandSpec({
-        command: ["auth", "set-key"],
-        usage: "blitzreels auth set-key --api-key KEY [--base-url URL]",
-    }),
-    commandSpec({
-        command: ["auth", "whoami"],
-        usage: "blitzreels auth whoami [--json]",
-    }),
-    commandSpec({
-        command: ["workspace", "settings", "get"],
-        usage: "blitzreels workspace settings get [--json]",
-    }),
-    commandSpec({
-        command: ["workspace", "settings", "update"],
-        usage: "blitzreels workspace settings update [--name NAME] [--description TEXT|null] [--protected-words foo,bar] [--icon-storage-key KEY|null] [--aspect-ratio 9:16] [--orientation portrait] [--resolution 1080p] [--frame-rate 30] [--auto-manage-broll true] [--caption-theme-id ID|null]",
-        flags: [
-            "name",
-            "description",
-            "protected-words",
-            "icon-storage-key",
-            "aspect-ratio",
-            "orientation",
-            "resolution",
-            "frame-rate",
-            "auto-manage-broll",
-            "caption-theme-id",
-        ],
-    }),
-    commandSpec({
-        command: ["projects", "list"],
-        usage: "blitzreels projects list [--search QUERY] [--status active|archived|all] [--limit 50] [--offset 0] [--cursor CURSOR] [--json]",
-        flags: ["search", "status", "limit", "offset", "cursor"],
-    }),
-    commandSpec({
-        command: ["projects", "create"],
-        usage: "blitzreels projects create --name NAME [--description TEXT] [--aspect-ratio 9:16] [--project-type video|carousel] [--carousel-settings-json JSON]",
-        flags: [
-            "name",
-            "description",
-            "aspect-ratio",
-            "project-type",
-            "carousel-settings-json",
-        ],
-    }),
-    commandSpec({
-        command: ["projects", "get"],
-        usage: "blitzreels projects get --project-id ID [--json]",
-        flags: ["project-id"],
-    }),
-    commandSpec({
-        command: ["projects", "rename"],
-        usage: "blitzreels projects rename --project-id ID --name NAME",
-        flags: ["project-id", "name"],
-    }),
-    commandSpec({
-        command: ["projects", "update"],
-        usage: "blitzreels projects update --project-id ID [--name NAME] [--description TEXT|null]",
-        flags: ["project-id", "name", "description"],
-    }),
-    commandSpec({
-        command: ["projects", "delete"],
-        usage: "blitzreels projects delete --project-id ID --confirm-delete",
-        flags: ["project-id", "confirm-delete"],
-    }),
-    commandSpec({
-        command: ["media", "list"],
-        usage: "blitzreels media list [--folder-id ID] [--asset-type video|audio|image|document] [--search QUERY] [--limit 100] [--offset 0] [--json]",
-        flags: ["folder-id", "asset-type", "search", "limit", "offset"],
-    }),
-    commandSpec({
-        command: ["media", "get"],
-        usage: "blitzreels media get --asset-id ID [--json]",
-        flags: ["asset-id"],
-    }),
-    commandSpec({
-        command: ["media", "delete"],
-        usage: "blitzreels media delete --asset-id ID --confirm-delete",
-        flags: ["asset-id", "confirm-delete"],
-    }),
-    commandSpec({
-        command: ["media", "upload"],
-        usage: "blitzreels media upload --file ./video.mp4 [--name NAME] [--content-type video/mp4] [--auto-process true] [--auto-transcribe true] [--auto-describe true] [--auto-suggest-shorts true]",
-        flags: [
-            "file",
-            "name",
-            "content-type",
-            "auto-process",
-            "auto-transcribe",
-            "auto-describe",
-            "auto-suggest-shorts",
-        ],
-    }),
-    commandSpec({
-        command: ["media", "import-youtube"],
-        usage: "blitzreels media import-youtube --url URL [--folder-id ID|root] [--quality 1080p] [--fps 30] [--audio-language fr|null]",
-        flags: ["url", "folder-id", "quality", "fps", "audio-language"],
-    }),
-    commandSpec({
-        command: ["media", "rename"],
-        usage: "blitzreels media rename --asset-id ID --name NAME",
-        flags: ["asset-id", "name"],
-    }),
-    commandSpec({
-        command: ["media", "update"],
-        usage: "blitzreels media update --asset-id ID [--name NAME] [--description TEXT|null] [--folder-id ID|root] [--allow-broll true]",
-        flags: ["asset-id", "name", "description", "folder-id", "allow-broll"],
-    }),
-    commandSpec({
-        command: ["media", "move"],
-        usage: "blitzreels media move --asset-id ID|--asset-ids ID1,ID2 --target-folder-id ID|root",
-        flags: ["asset-id", "asset-ids", "target-folder-id"],
-    }),
-    commandSpec({
-        command: ["media", "attach"],
-        usage: "blitzreels media attach --project-id ID --asset-id ID [--at 0] [--duration 4] [--layer-index 2] [--allow-duplicate true] [--position-preset center] [--position-x 0] [--position-y 0] [--width-px 320] [--height-px 180] [--scale 1.2] [--opacity 0.9] [--animation-preset popIn]",
-        flags: [
-            "project-id",
-            "asset-id",
-            "at",
-            "duration",
-            "layer-index",
-            "allow-duplicate",
-            "position-preset",
-            "position-x",
-            "position-y",
-            "width-px",
-            "height-px",
-            "scale",
-            "opacity",
-            "animation-preset",
-        ],
-    }),
-    commandSpec({
-        command: ["media", "folders", "list"],
-        usage: "blitzreels media folders list [--parent-folder-id ID] [--json]",
-        flags: ["parent-folder-id"],
-    }),
-    commandSpec({
-        command: ["media", "folders", "create"],
-        usage: "blitzreels media folders create --name NAME [--parent-folder-id ID] [--description TEXT|null] [--icon-type video]",
-        flags: ["name", "parent-folder-id", "description", "icon-type"],
-    }),
-    commandSpec({
-        command: ["media", "folders", "rename"],
-        usage: "blitzreels media folders rename --folder-id ID --name NAME",
-        flags: ["folder-id", "name"],
-    }),
-    commandSpec({
-        command: ["media", "folders", "update"],
-        usage: "blitzreels media folders update --folder-id ID [--name NAME] [--parent-folder-id ID|root] [--description TEXT|null] [--icon-type video]",
-        flags: [
-            "folder-id",
-            "name",
-            "parent-folder-id",
-            "description",
-            "icon-type",
-        ],
-    }),
-    commandSpec({
-        command: ["media", "folders", "delete"],
-        usage: "blitzreels media folders delete --folder-id ID --confirm-delete [--cascade true]",
-        flags: ["folder-id", "confirm-delete", "cascade"],
-    }),
-    commandSpec({
-        command: ["project", "inspect"],
-        usage: "blitzreels project inspect --project-id ID [--mode full] [--json]",
-        flags: ["project-id", "mode"],
-    }),
-    commandSpec({
-        command: ["project", "timeline"],
-        usage: "blitzreels project timeline --project-id ID [--json]",
-        flags: ["project-id"],
-    }),
-    commandSpec({
-        command: ["project", "snapshot"],
-        usage: "blitzreels project snapshot --project-id ID --at 00:03 [--target-width 608] [--image-format jpeg|png|webp] [--json]",
-        flags: ["project-id", "at", "target-width", "image-format"],
-    }),
-    commandSpec({
-        command: ["project", "snapshots"],
-        usage: "blitzreels project snapshots --project-id ID --at 00:01,00:03 [--target-width 608] [--image-format jpeg|png|webp] [--json]",
-        flags: ["project-id", "at", "target-width", "image-format"],
-    }),
-    commandSpec({
-        command: ["timeline", "transform"],
-        usage: "blitzreels timeline transform --project-id ID --timeline-item-id ID [--position-x 0] [--position-y 0] [--width-px 320|null] [--height-px 180|null] [--keep-aspect-ratio true]",
-        flags: [
-            "project-id",
-            "timeline-item-id",
-            "position-x",
-            "position-y",
-            "width-px",
-            "height-px",
-            "keep-aspect-ratio",
-        ],
-    }),
-    commandSpec({
-        command: ["timeline", "move"],
-        usage: "blitzreels timeline move --project-id ID --timeline-item-id ID --at 00:03 [--layer-index 2]",
-        flags: ["project-id", "timeline-item-id", "at", "layer-index"],
-    }),
-    commandSpec({
-        command: ["timeline", "delete"],
-        usage: "blitzreels timeline delete --project-id ID --timeline-item-id ID|--timeline-item-ids ID1,ID2 [--auto-pack true]",
-        flags: ["project-id", "timeline-item-id", "timeline-item-ids", "auto-pack"],
-    }),
-    commandSpec({
-        command: ["text", "add"],
-        usage: "blitzreels text add --project-id ID --text \"Hook\" [--name NAME] [--at 0] [--duration 4] [--layer-index 2] [--spec-json JSON] [--font-family Inter] [--font-size 64] [--font-weight 700] [--color '#fff'] [--background-color '#000'] [--padding-x 32] [--padding-y 16] [--border-radius 24] [--top '18%'] [--left '50%'] [--text-align center] [--text-shadow '0 6px 18px #000'] [--no-background]",
-        flags: [
-            "project-id",
-            "text",
-            "name",
-            "at",
-            "duration",
-            "layer-index",
-            ...TEXT_STYLE_FLAGS,
-        ],
-    }),
-    commandSpec({
-        command: ["text", "list"],
-        usage: "blitzreels text list --project-id ID [--json]",
-        flags: ["project-id"],
-    }),
-    commandSpec({
-        command: ["text", "update"],
-        usage: "blitzreels text update --project-id ID --content-item-id ID [--text \"New hook\"] [--name NAME] [--spec-json JSON] [--font-family Pacifico] [--font-size 82] [--font-weight 700] [--color '#17FFA6'] [--background-color '#051914'] [--padding-x 32] [--padding-y 16] [--border-radius 24] [--top '18%'] [--left '50%'] [--text-align center] [--text-shadow '0 6px 18px #000'] [--no-background]",
-        flags: [
-            "project-id",
-            "content-item-id",
-            "text",
-            "name",
-            ...TEXT_STYLE_FLAGS,
-        ],
-    }),
-    commandSpec({
-        command: ["text", "remove"],
-        usage: "blitzreels text remove --project-id ID --content-item-id ID",
-        flags: ["project-id", "content-item-id"],
-    }),
-    commandSpec({
-        command: ["audio", "add"],
-        usage: "blitzreels audio add --project-id ID --asset-id ID [--at 0] [--duration 30] [--volume 0.6] [--fade-in 0.5] [--fade-out 0.5] [--loop true]",
-        flags: [
-            "project-id",
-            "asset-id",
-            "at",
-            "duration",
-            "volume",
-            "fade-in",
-            "fade-out",
-            "loop",
-        ],
-    }),
-    commandSpec({
-        command: ["silence", "plan"],
-        usage: "blitzreels silence plan --project-id ID --timeline-item-id ID [--padding-ms 120] [--silence-threshold-db -35] [--min-silence-duration 0.25] [--remove-blips-max-duration 0.12] [--use-caption-validation true] [--json]",
-        flags: [
-            "project-id",
-            "timeline-item-id",
-            "padding-ms",
-            "silence-threshold-db",
-            "min-silence-duration",
-            "remove-blips-max-duration",
-            "use-caption-validation",
-        ],
-    }),
-    commandSpec({
-        command: ["silence", "apply"],
-        usage: "blitzreels silence apply --project-id ID --timeline-item-id ID --confirm-preview [--padding-ms 120] [--silence-threshold-db -35] [--min-silence-duration 0.25] [--remove-blips-max-duration 0.12] [--use-caption-validation true] [--delete-silent-clips true] [--manual-segment-overrides-json JSON]",
-        flags: [
-            "project-id",
-            "timeline-item-id",
-            "confirm-preview",
-            "padding-ms",
-            "silence-threshold-db",
-            "min-silence-duration",
-            "remove-blips-max-duration",
-            "use-caption-validation",
-            "delete-silent-clips",
-            "manual-segment-overrides-json",
-        ],
-    }),
-    commandSpec({
-        command: ["mistakes", "plan"],
-        usage: "blitzreels mistakes plan --project-id ID --timeline-item-id ID [--json]",
-        flags: ["project-id", "timeline-item-id"],
-    }),
-    commandSpec({
-        command: ["mistakes", "apply"],
-        usage: "blitzreels mistakes apply --project-id ID --timeline-item-id ID --confirm-preview [--plan-json JSON] [--manual-verdicts-json JSON] [--delete-mistakes true]",
-        flags: [
-            "project-id",
-            "timeline-item-id",
-            "confirm-preview",
-            "plan-json",
-            "manual-verdicts-json",
-            "delete-mistakes",
-        ],
-    }),
-    commandSpec({
-        command: ["captions", "words", "list"],
-        usage: "blitzreels captions words list --project-id ID [--timeline-item-id ID] [--match-text TEXT] [--limit 100] [--offset 0]",
-        flags: ["project-id", "timeline-item-id", "match-text", "limit", "offset"],
-    }),
-    commandSpec({
-        command: ["captions", "words", "text"],
-        usage: 'blitzreels captions words text --project-id ID --word-id ID --text "Fix"|--new-text "Fix"',
-        flags: ["project-id", "word-id", "text", "new-text"],
-    }),
-    commandSpec({
-        command: ["captions", "words", "batch-text"],
-        usage: 'blitzreels captions words batch-text --project-id ID --updates-json \'[{"word_id":"...","new_text":"..."}]\'',
-        flags: ["project-id", "updates-json"],
-    }),
-    commandSpec({
-        command: ["captions", "words", "style"],
-        usage: "blitzreels captions words style --project-id ID [--word-id ID|--word-ids IDs|--timeline-item-id ID|--match-text TEXT|--match-pattern numbers|caps|exclamations] [--style-json JSON|null] [--font-family Pacifico] [--font-weight 700] [--font-style italic] [--color '#17FFA6'] [--active-color '#fff'] [--background-color '#051914'] [--active-animation pop] [--text-transform uppercase] [--text-shadow '0 6px 18px #000'] [--glow-color '#17FFA6'] [--glow-blur-px 18] [--scale 1.45] [--offset-x 0] [--offset-y -8] [--rotation-deg -2] [--letter-spacing 1] [--opacity 1] [--clear-existing true]",
-        flags: [
-            "project-id",
-            ...CAPTION_WORD_SELECTOR_FLAGS,
-            ...CAPTION_WORD_STYLE_FLAGS,
-        ],
-    }),
-    commandSpec({
-        command: ["captions", "words", "emphasis"],
-        usage: "blitzreels captions words emphasis --project-id ID [--word-id ID|--word-ids IDs|--timeline-item-id ID|--match-text TEXT|--match-pattern numbers|caps|exclamations] [--emphasis true]",
-        flags: ["project-id", ...CAPTION_WORD_SELECTOR_FLAGS, "emphasis"],
-    }),
-    commandSpec({
-        command: ["captions", "words", "delete"],
-        usage: "blitzreels captions words delete --project-id ID --word-id ID|--word-ids ID1,ID2",
-        flags: ["project-id", "word-id", "word-ids"],
-    }),
-    commandSpec({
-        command: ["captions", "words", "merge"],
-        usage: 'blitzreels captions words merge --project-id ID --word-ids ID1,ID2 [--text "Merged"]',
-        flags: ["project-id", "word-ids", "text"],
-    }),
-    commandSpec({
-        command: ["captions", "words", "split"],
-        usage: 'blitzreels captions words split --project-id ID --word-id ID --words "foo,bar"',
-        flags: ["project-id", "word-id", "words"],
-    }),
-    commandSpec({
-        command: ["captions", "themes", "list"],
-        usage: "blitzreels captions themes list [--json]",
-    }),
-    commandSpec({
-        command: ["captions", "theme", "set"],
-        usage: "blitzreels captions theme set --project-id ID --theme-id ID",
-        flags: ["project-id", "theme-id"],
-    }),
-    commandSpec({
-        command: ["captions", "theme", "set-default"],
-        usage: "blitzreels captions theme set-default --theme-id ID",
-        flags: ["theme-id"],
-    }),
-    commandSpec({
-        command: ["exports", "start"],
-        usage: "blitzreels exports start --project-id ID [--resolution 1080p] [--format mp4] [--include-captions true]",
-        flags: ["project-id", "resolution", "format", "include-captions"],
-    }),
-    commandSpec({
-        command: ["exports", "wait"],
-        usage: "blitzreels exports wait --export-id ID [--interval-ms 3000] [--timeout-ms 1200000] [--json]",
-        flags: ["export-id", "interval-ms", "timeout-ms"],
-    }),
-    commandSpec({
-        command: ["exports", "download"],
-        usage: "blitzreels exports download --export-id ID --output ./short.mp4",
-        flags: ["export-id", "output"],
-    }),
-    commandSpec({
-        command: ["api", "docs"],
-        usage: "blitzreels api docs",
-    }),
-    commandSpec({
-        command: ["api", "spec"],
-        usage: "blitzreels api spec",
-    }),
-];
 class CliUsageError extends Error {
     code;
     suggestions;
@@ -464,33 +34,118 @@ async function main() {
         return;
     }
     if (getBooleanFlag({ flags: parsed.flags, name: "help" })) {
-        printCommandHelpOrThrow({ command: parsed.command });
+        if (parsed.command.length === 0) {
+            printHelp();
+            return;
+        }
+        printCommandOrGroupHelpOrThrow({ command: parsed.command });
         return;
     }
+    if (!findCommandSpec({ command: parsed.command })) {
+        const groupSpecs = findGroupCommandSpecs({ command: parsed.command });
+        if (groupSpecs.length > 0) {
+            printGroupHelp({ command: parsed.command, specs: groupSpecs });
+            return;
+        }
+    }
     validateParsedArgs({ parsed });
-    const config = await loadConfig();
-    const apiKey = getStringFlag({ flags: parsed.flags, name: "api-key" }) ??
-        process.env.BLITZREELS_API_KEY ??
-        config.apiKey;
-    const baseUrl = getStringFlag({ flags: parsed.flags, name: "base-url" }) ??
-        process.env.BLITZREELS_BASE_URL ??
-        config.baseUrl;
-    const clientConfig = {
-        apiKey,
-        baseUrl,
-        fetchFn: undefined,
-        userAgent: "blitzreels-cli/0.0.0",
-    };
+    validateSafeInputs({ parsed });
+    const storedConfig = await loadConfig();
+    const config = resolveRuntimeConfig({
+        flags: parsed.flags,
+        storedConfig,
+    });
     const context = {
         args: parsed,
         json: getBooleanFlag({ flags: parsed.flags, name: "json" }),
-        client: new BlitzReelsClient(clientConfig),
-        config: { apiKey, baseUrl, keyStorage: config.keyStorage },
+        dryRun: getBooleanFlag({ flags: parsed.flags, name: "dry-run" }),
+        fields: parseCsvFlag({ flags: parsed.flags, name: "fields" }),
+        client: createCliClient({ config }),
+        config,
     };
     await runCommand({ context });
+    await maybePrintUpdateNotice({
+        parsed,
+        baseUrl: config.baseUrl,
+        json: context.json,
+    });
 }
 async function runCommand({ context }) {
     const [group, action, subaction] = context.args.command;
+    if (group === "version") {
+        const update = await getUpdateStatus({
+            baseUrl: context.config.baseUrl,
+            cachePolicy: "refresh",
+        });
+        printResult({
+            json: context.json,
+            value: {
+                current: CLI_VERSION,
+                latest: update.manifest.latest,
+                update_available: update.updateAvailable,
+                upgrade: update.manifest.upgrade,
+                changelog_url: update.manifest.url,
+            },
+            human: buildVersionLines({ update }),
+        });
+        return;
+    }
+    if (group === "doctor") {
+        const update = await getUpdateStatus({
+            baseUrl: context.config.baseUrl,
+            cachePolicy: "refresh",
+        });
+        printResult({
+            json: context.json,
+            value: {
+                cli: {
+                    current: CLI_VERSION,
+                    latest: update.manifest.latest,
+                    update_available: update.updateAvailable,
+                    supported: !isVersionLessThan({
+                        left: CLI_VERSION,
+                        right: update.manifest.minSupported,
+                    }),
+                },
+                config: {
+                    api_key: context.config.apiKey ? "configured" : "missing",
+                    base_url: context.config.baseUrl ?? "https://www.blitzreels.com/api/v1",
+                    key_storage: context.config.keyStorage ?? "none",
+                },
+                upgrade: update.manifest.upgrade,
+            },
+            human: buildDoctorLines({ context, update }),
+        });
+        return;
+    }
+    if (group === "agent-context" || group === "schema") {
+        const result = buildAgentContext({
+            commandFilter: getStringFlag({
+                flags: context.args.flags,
+                name: "command",
+            }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: buildAgentContextLines({ value: result }),
+        });
+        return;
+    }
+    if (group === "prime" || group === "llms") {
+        const result = buildAgentPrime({
+            commandFilter: getStringFlag({
+                flags: context.args.flags,
+                name: "command",
+            }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: buildAgentPrimeLines({ value: result }),
+        });
+        return;
+    }
     if (group === "auth" && action === "set-key") {
         await setApiKey({ context });
         return;
@@ -501,14 +156,22 @@ async function runCommand({ context }) {
     }
     if (group === "auth" && action === "whoami") {
         const result = await context.client.auth.validate();
+        const displayEnvironment = resolveDisplayEnvironment({
+            baseUrl: context.config.baseUrl,
+            environment: result.environment,
+        });
+        const value = {
+            ...result,
+            display_environment: displayEnvironment,
+        };
         printResult({
             json: context.json,
-            value: result,
+            value,
             human: [
                 `Workspace: ${result.organization_id}`,
                 `User: ${result.user_id}`,
                 `Plan: ${result.plan}`,
-                `Environment: ${result.environment}`,
+                `Environment: ${displayEnvironment}`,
                 `Docs: ${result.docs_url}`,
             ],
         });
@@ -517,10 +180,18 @@ async function runCommand({ context }) {
     if (group === "api" && action === "spec") {
         const url = new URL(context.config.baseUrl ?? "https://www.blitzreels.com/api/v1");
         url.pathname = "/api/openapi.json";
+        const response = await fetch(url, {
+            headers: { Accept: "application/json" },
+        });
+        const spec = await readJsonResponse({
+            response,
+            url: url.toString(),
+            action: "fetch OpenAPI spec",
+        });
         printResult({
-            json: context.json,
-            value: { url: url.toString() },
-            human: [url.toString()],
+            json: true,
+            value: spec,
+            human: [],
         });
         return;
     }
@@ -534,6 +205,14 @@ async function runCommand({ context }) {
         });
         return;
     }
+    if (context.dryRun) {
+        printResult({
+            json: true,
+            value: buildDryRunPreview({ context }),
+            human: [],
+        });
+        return;
+    }
     requireApiKey({ apiKey: context.config.apiKey });
     if (group === "workspace" && action === "settings" && subaction === "get") {
         const result = await context.client.workspace.getSettings();
@@ -575,120 +254,27 @@ async function runCommand({ context }) {
         });
         return;
     }
-    if (group === "projects" && action === "list") {
-        const result = await context.client.projects.list({
-            limit: getNumberFlag({ flags: context.args.flags, name: "limit" }),
-            cursor: getStringFlag({ flags: context.args.flags, name: "cursor" }),
-            offset: getNumberFlag({ flags: context.args.flags, name: "offset" }),
-            search: getStringFlag({ flags: context.args.flags, name: "search" }),
-            status: parseProjectStatus({
-                value: getStringFlag({ flags: context.args.flags, name: "status" }),
-            }),
-        });
-        printResult({
-            json: context.json,
-            value: result,
-            human: result.projects.map((project) => `${project.id} ${project.status} ${project.name} (${project.aspect_ratio ?? "-"})`),
-        });
-        return;
-    }
-    if (group === "projects" && action === "create") {
-        const result = await context.client.projects.create({
-            name: requireStringFlag({ flags: context.args.flags, name: "name" }),
-            description: getStringFlag({
-                flags: context.args.flags,
-                name: "description",
-            }),
-            aspectRatio: parseAspectRatio({
-                value: getStringFlag({
-                    flags: context.args.flags,
-                    name: "aspect-ratio",
-                }),
-            }),
-            projectType: parseProjectType({
-                value: getStringFlag({
-                    flags: context.args.flags,
-                    name: "project-type",
-                }),
-            }),
-            carouselSettings: parseJsonObjectFlag({
-                flags: context.args.flags,
-                name: "carousel-settings-json",
-            }),
-        });
-        printResult({
-            json: context.json,
-            value: result,
-            human: [`Project created: ${result.id} ${result.name}`],
-        });
-        return;
-    }
-    if (group === "projects" && action === "get") {
-        const result = await context.client.projects.get({
-            projectId: requireStringFlag({
-                flags: context.args.flags,
-                name: "project-id",
-            }),
-        });
-        printResult({
-            json: context.json,
-            value: result,
-            human: [
-                `${result.id} ${result.status} ${result.name}`,
-                `Description: ${result.description ?? ""}`,
-            ],
-        });
-        return;
-    }
-    if (group === "projects" && action === "rename") {
-        const result = await context.client.projects.update({
-            projectId: requireStringFlag({
-                flags: context.args.flags,
-                name: "project-id",
-            }),
-            name: requireStringFlag({ flags: context.args.flags, name: "name" }),
-            description: undefined,
-        });
-        printResult({
-            json: context.json,
-            value: result,
-            human: [`Project renamed: ${result.id} ${result.name}`],
-        });
-        return;
-    }
-    if (group === "projects" && action === "update") {
-        const result = await context.client.projects.update({
-            projectId: requireStringFlag({
-                flags: context.args.flags,
-                name: "project-id",
-            }),
-            name: getStringFlag({ flags: context.args.flags, name: "name" }),
-            description: parseNullableStringFlag({
-                flags: context.args.flags,
-                name: "description",
-            }),
-        });
-        printResult({
-            json: context.json,
-            value: result,
-            human: [`Project updated: ${result.id} ${result.name}`],
-        });
-        return;
-    }
-    if (group === "projects" && action === "delete") {
-        requireConfirmDelete({ flags: context.args.flags });
-        const result = await context.client.projects.delete({
-            projectId: requireStringFlag({
-                flags: context.args.flags,
-                name: "project-id",
-            }),
-        });
-        printResult({
-            json: context.json,
-            value: result,
-            human: ["Project deleted."],
+    if (group === "projects") {
+        const handled = await handleProjectsCommand({
+            context,
+            action,
+            helpers: {
+                getBooleanFlag,
+                getNumberFlag,
+                getStringFlag,
+                requireStringFlag,
+                parseNullableStringFlag,
+                parseProjectStatus,
+                parseAspectRatio,
+                parseProjectType,
+                parseJsonObjectFlag,
+                buildProjectDashboardUrl,
+                printResult,
+            },
         });
-        return;
+        if (handled) {
+            return;
+        }
     }
     if (group === "media" && action === "list") {
         const result = await context.client.media.list({
@@ -719,13 +305,31 @@ async function runCommand({ context }) {
             value: result,
             human: [
                 `${result.asset.id} ${result.asset.assetType} ${result.asset.name}`,
+                `Processing: ${result.asset.processingStatus ?? "unknown"}${result.asset.processingSubstage ? `/${result.asset.processingSubstage}` : ""}`,
+                ...(result.asset.processingError
+                    ? [`Processing error: ${result.asset.processingError}`]
+                    : []),
+                `Retryable: ${result.asset.retryable ? "yes" : "no"}`,
+                ...(result.asset.providerRequestIds.processJobRunId
+                    ? [`Process job: ${result.asset.providerRequestIds.processJobRunId}`]
+                    : []),
+                ...(result.asset.providerRequestIds.transcribeJobRunId
+                    ? [
+                        `Transcribe job: ${result.asset.providerRequestIds.transcribeJobRunId}`,
+                    ]
+                    : []),
                 `URL: ${result.asset.fileUrl ?? ""}`,
             ],
         });
         return;
     }
     if (group === "media" && action === "delete") {
-        requireConfirmDelete({ flags: context.args.flags });
+        requireDeleteConfirmation({
+            confirmed: getBooleanFlag({
+                flags: context.args.flags,
+                name: "confirm-delete",
+            }),
+        });
         const result = await context.client.media.delete({
             assetId: requireStringFlag({
                 flags: context.args.flags,
@@ -833,7 +437,8 @@ async function runCommand({ context }) {
         });
         return;
     }
-    if (group === "media" && action === "attach") {
+    if ((group === "media" && action === "attach") ||
+        (group === "broll" && action === "add")) {
         const result = await context.client.media.attachToProject({
             projectId: requireStringFlag({
                 flags: context.args.flags,
@@ -891,24 +496,6 @@ async function runCommand({ context }) {
                 }),
             }),
         });
-        const requestedLayer = getNumberFlag({
-            flags: context.args.flags,
-            name: "layer-index",
-        });
-        if (requestedLayer !== undefined) {
-            await Promise.all(result.inserted
-                .map((item) => item.timeline_item_id)
-                .filter((item) => typeof item === "string")
-                .map((timelineItemId) => context.client.timeline.move({
-                projectId: requireStringFlag({
-                    flags: context.args.flags,
-                    name: "project-id",
-                }),
-                timelineItemId,
-                newStartSeconds: result.inserted.find((item) => item.timeline_item_id === timelineItemId)?.start_seconds ?? 0,
-                newLayerIndex: requestedLayer,
-            })));
-        }
         printResult({
             json: context.json,
             value: result,
@@ -918,45 +505,268 @@ async function runCommand({ context }) {
         });
         return;
     }
-    if (group === "media" && action === "folders" && subaction === "list") {
-        const result = await context.client.media.folders.list({
-            parentFolderId: getStringFlag({
+    if (group === "media" && action === "overlay" && subaction === "update") {
+        const result = await context.client.media.updateOverlay({
+            projectId: requireStringFlag({
                 flags: context.args.flags,
-                name: "parent-folder-id",
+                name: "project-id",
+            }),
+            timelineItemId: requireStringFlag({
+                flags: context.args.flags,
+                name: "timeline-item-id",
+            }),
+            positionPreset: parseMediaPositionPreset({
+                value: getStringFlag({
+                    flags: context.args.flags,
+                    name: "position-preset",
+                }),
+            }),
+            positionX: getNumberFlag({
+                flags: context.args.flags,
+                name: "position-x",
+            }),
+            positionY: getNumberFlag({
+                flags: context.args.flags,
+                name: "position-y",
+            }),
+            widthPx: getNumberFlag({
+                flags: context.args.flags,
+                name: "width-px",
+            }),
+            heightPx: getNumberFlag({
+                flags: context.args.flags,
+                name: "height-px",
+            }),
+            scale: getNumberFlag({ flags: context.args.flags, name: "scale" }),
+            animationPreset: parseMediaAnimationPreset({
+                value: getStringFlag({
+                    flags: context.args.flags,
+                    name: "animation-preset",
+                }),
+            }),
+            removeAnimations: getOptionalBooleanFlag({
+                flags: context.args.flags,
+                name: "remove-animations",
+            }),
+            blurredBackground: getOptionalBooleanFlag({
+                flags: context.args.flags,
+                name: "blurred-background",
             }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: result.folders.map((folder) => `${folder.id} ${folder.name} (${folder.assetCount ?? 0} assets)`),
+            human: [result.message],
         });
         return;
     }
-    if (group === "media" && action === "folders" && subaction === "create") {
-        const result = await context.client.media.folders.create({
-            name: requireStringFlag({ flags: context.args.flags, name: "name" }),
-            parentFolderId: parseFolderIdFlag({
-                flags: context.args.flags,
-                name: "parent-folder-id",
-            }),
-            description: parseNullableStringFlag({
-                flags: context.args.flags,
-                name: "description",
-            }),
-            iconType: getStringFlag({ flags: context.args.flags, name: "icon-type" }),
-        });
+    if (group === "media" && action === "wait") {
+        const result = await waitForMediaAsset({ context });
         printResult({
             json: context.json,
             value: result,
-            human: [`Folder created: ${result.folder.id} ${result.folder.name}`],
+            human: [
+                `Media ready: ${result.asset.id} ${result.asset.name} (${result.ready_for.join(", ")})`,
+                `Processing: ${result.asset.processingStatus ?? "unknown"}${result.asset.processingSubstage ? `/${result.asset.processingSubstage}` : ""}`,
+                ...(result.asset.processingError
+                    ? [`Processing error: ${result.asset.processingError}`]
+                    : []),
+            ],
         });
         return;
     }
-    if (group === "media" && action === "folders" && subaction === "rename") {
-        const result = await context.client.media.folders.update({
-            folderId: requireStringFlag({
+    if (group === "media" && action === "shorts" && subaction === "list") {
+        const result = await context.client.media.shorts.list({
+            assetId: requireStringFlag({
                 flags: context.args.flags,
-                name: "folder-id",
+                name: "asset-id",
+            }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [
+                `Saved: ${result.saved.length}`,
+                `Drafts: ${result.drafts.length}`,
+                ...[...result.saved, ...result.drafts].map((suggestion) => JSON.stringify(suggestion)),
+            ],
+        });
+        return;
+    }
+    if (group === "media" && action === "shorts" && subaction === "generate") {
+        const result = await context.client.media.shorts.generate({
+            assetId: requireStringFlag({
+                flags: context.args.flags,
+                name: "asset-id",
+            }),
+            contentProfile: parseShortContentProfile({
+                value: getStringFlag({
+                    flags: context.args.flags,
+                    name: "content-profile",
+                }),
+            }),
+            autoTrimSilence: getOptionalBooleanFlag({
+                flags: context.args.flags,
+                name: "auto-trim-silence",
+            }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [`Short suggestion generation queued: ${result.run_id}`],
+        });
+        return;
+    }
+    if (group === "media" && action === "shorts" && subaction === "apply") {
+        const result = await context.client.media.shorts.apply({
+            assetId: requireStringFlag({
+                flags: context.args.flags,
+                name: "asset-id",
+            }),
+            suggestionId: requireStringFlag({
+                flags: context.args.flags,
+                name: "suggestion-id",
+            }),
+            projectId: requireStringFlag({
+                flags: context.args.flags,
+                name: "project-id",
+            }),
+            captionStyleId: parseNullableStringFlag({
+                flags: context.args.flags,
+                name: "caption-style-id",
+            }),
+            markSaved: getOptionalBooleanFlag({
+                flags: context.args.flags,
+                name: "mark-saved",
+            }),
+            allowUnverifiedExport: getOptionalBooleanFlag({
+                flags: context.args.flags,
+                name: "allow-unverified-export",
+            }),
+            automaticLayout: parseJsonObjectFlag({
+                flags: context.args.flags,
+                name: "automatic-layout-json",
+            }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [
+                `Short applied: ${result.timeline_item_id} in project ${result.project_id}`,
+            ],
+        });
+        return;
+    }
+    if (group === "clips" && action === "create") {
+        const result = await context.client.clips.create(toCreateClipOptions({ flags: context.args.flags }));
+        printClipResult({ context, result });
+        return;
+    }
+    if (group === "clips" && action === "get") {
+        const result = await context.client.clips.get({
+            clipId: requireStringFlag({
+                flags: context.args.flags,
+                name: "clip-id",
+            }),
+        });
+        printClipResult({ context, result });
+        return;
+    }
+    if (group === "clips" && action === "wait") {
+        const result = await waitForClip({ context });
+        printClipResult({ context, result });
+        return;
+    }
+    if (group === "clips" && action === "reselect") {
+        const result = await context.client.clips.reselect({
+            clipId: requireStringFlag({
+                flags: context.args.flags,
+                name: "clip-id",
+            }),
+            selection: buildClipSelection({ flags: context.args.flags }),
+            target: buildClipTarget({
+                flags: context.args.flags,
+                requireMaxDuration: false,
+            }),
+        });
+        printClipResult({ context, result });
+        return;
+    }
+    if (group === "clips" && action === "repair") {
+        const result = await context.client.clips.repair({
+            clipId: requireStringFlag({
+                flags: context.args.flags,
+                name: "clip-id",
+            }),
+            repairMode: parseClipRepairMode({
+                value: getStringFlag({
+                    flags: context.args.flags,
+                    name: "repair-mode",
+                }),
+            }),
+        });
+        printClipResult({ context, result });
+        return;
+    }
+    if (group === "clips" && action === "export") {
+        const result = await context.client.clips.export({
+            clipId: requireStringFlag({
+                flags: context.args.flags,
+                name: "clip-id",
+            }),
+            resolution: parseClipExportResolution({
+                value: getStringFlag({ flags: context.args.flags, name: "resolution" }),
+            }),
+            format: parseClipExportFormat({
+                value: getStringFlag({ flags: context.args.flags, name: "format" }),
+            }),
+            allowBlockingQaBypass: getOptionalBooleanFlag({
+                flags: context.args.flags,
+                name: "allow-blocking-qa-bypass",
+            }) ?? false,
+        });
+        printClipResult({ context, result });
+        return;
+    }
+    if (group === "media" && action === "folders" && subaction === "list") {
+        const result = await context.client.media.folders.list({
+            parentFolderId: getStringFlag({
+                flags: context.args.flags,
+                name: "parent-folder-id",
+            }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: result.folders.map((folder) => `${folder.id} ${folder.name} (${folder.assetCount ?? 0} assets)`),
+        });
+        return;
+    }
+    if (group === "media" && action === "folders" && subaction === "create") {
+        const result = await context.client.media.folders.create({
+            name: requireStringFlag({ flags: context.args.flags, name: "name" }),
+            parentFolderId: parseFolderIdFlag({
+                flags: context.args.flags,
+                name: "parent-folder-id",
+            }),
+            description: parseNullableStringFlag({
+                flags: context.args.flags,
+                name: "description",
+            }),
+            iconType: getStringFlag({ flags: context.args.flags, name: "icon-type" }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [`Folder created: ${result.folder.id} ${result.folder.name}`],
+        });
+        return;
+    }
+    if (group === "media" && action === "folders" && subaction === "rename") {
+        const result = await context.client.media.folders.update({
+            folderId: requireStringFlag({
+                flags: context.args.flags,
+                name: "folder-id",
             }),
             name: requireStringFlag({ flags: context.args.flags, name: "name" }),
             parentFolderId: undefined,
@@ -995,7 +805,12 @@ async function runCommand({ context }) {
         return;
     }
     if (group === "media" && action === "folders" && subaction === "delete") {
-        requireConfirmDelete({ flags: context.args.flags });
+        requireDeleteConfirmation({
+            confirmed: getBooleanFlag({
+                flags: context.args.flags,
+                name: "confirm-delete",
+            }),
+        });
         const result = await context.client.media.folders.delete({
             folderId: requireStringFlag({
                 flags: context.args.flags,
@@ -1042,7 +857,10 @@ async function runCommand({ context }) {
         printResult({
             json: context.json,
             value: result,
-            human: [JSON.stringify(result.data, null, 2)],
+            human: [
+                ...timelineLayerModelHelp(),
+                JSON.stringify(result.data, null, 2),
+            ],
         });
         return;
     }
@@ -1203,6 +1021,10 @@ async function runCommand({ context }) {
             text: getStringFlag({ flags: context.args.flags, name: "text" }),
             name: getStringFlag({ flags: context.args.flags, name: "name" }),
             spec,
+            durationSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "duration",
+            }),
         });
         printResult({
             json: context.json,
@@ -1293,45 +1115,60 @@ async function runCommand({ context }) {
         });
         return;
     }
-    if (group === "audio" && action === "add") {
-        const result = await context.client.audio.add({
+    if (group === "effects" && action === "zoom" && subaction === "add") {
+        const durationSeconds = getNumberFlag({
+            flags: context.args.flags,
+            name: "duration",
+        });
+        const result = await context.client.effects.zoom.add({
             projectId: requireStringFlag({
                 flags: context.args.flags,
                 name: "project-id",
             }),
-            assetId: requireStringFlag({
+            timelineItemId: getStringFlag({
                 flags: context.args.flags,
-                name: "asset-id",
+                name: "timeline-item-id",
             }),
-            startSeconds: parseTimecode({
-                value: getStringFlag({ flags: context.args.flags, name: "at" }) ?? "0",
+            contentItemId: getStringFlag({
+                flags: context.args.flags,
+                name: "content-item-id",
             }),
-            durationSeconds: getNumberFlag({
+            effectId: getStringFlag({
                 flags: context.args.flags,
-                name: "duration",
+                name: "effect-id",
             }),
-            volume: getNumberFlag({ flags: context.args.flags, name: "volume" }),
-            fadeInSeconds: getNumberFlag({
+            name: getStringFlag({ flags: context.args.flags, name: "name" }),
+            startTimeSeconds: getTimelineStartFlag({ flags: context.args.flags }),
+            durationSeconds,
+            easing: parseEffectEasing({
+                value: getStringFlag({ flags: context.args.flags, name: "easing" }),
+            }),
+            layerIndex: getNumberFlag({
                 flags: context.args.flags,
-                name: "fade-in",
+                name: "layer-index",
             }),
-            fadeOutSeconds: getNumberFlag({
+            orderIndex: getNumberFlag({
                 flags: context.args.flags,
-                name: "fade-out",
+                name: "order-index",
+            }),
+            settings: buildZoomEffectSettings({
+                flags: context.args.flags,
+                durationSeconds,
             }),
-            loop: getOptionalBooleanFlag({ flags: context.args.flags, name: "loop" }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: [
-                `Inserted ${result.summary.inserted}/${result.summary.total} audio item(s).`,
-            ],
+            human: [`Zoom effect added: ${result.timeline_item_id}`],
         });
         return;
     }
-    if (group === "silence" && action === "plan") {
-        const result = await context.client.silence.plan({
+    if (group === "effects" && action === "zoom" && subaction === "update") {
+        const durationSeconds = getNumberFlag({
+            flags: context.args.flags,
+            name: "duration",
+        });
+        const result = await context.client.effects.zoom.update({
             projectId: requireStringFlag({
                 flags: context.args.flags,
                 name: "project-id",
@@ -1340,83 +1177,71 @@ async function runCommand({ context }) {
                 flags: context.args.flags,
                 name: "timeline-item-id",
             }),
-            paddingMs: getNumberFlag({
-                flags: context.args.flags,
-                name: "padding-ms",
-            }),
-            silenceThresholdDb: getNumberFlag({
-                flags: context.args.flags,
-                name: "silence-threshold-db",
-            }),
-            minSilenceDurationSeconds: getNumberFlag({
-                flags: context.args.flags,
-                name: "min-silence-duration",
-            }),
-            removeBlipsMaxDurationSeconds: getNumberFlag({
-                flags: context.args.flags,
-                name: "remove-blips-max-duration",
+            durationSeconds,
+            easing: parseEffectEasing({
+                value: getStringFlag({ flags: context.args.flags, name: "easing" }),
             }),
-            useCaptionValidation: getOptionalBooleanFlag({
+            settings: buildZoomEffectSettings({
                 flags: context.args.flags,
-                name: "use-caption-validation",
+                durationSeconds,
             }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: [JSON.stringify(result, null, 2)],
+            human: [`Zoom effect updated: ${result.timeline_item_id}`],
         });
         return;
     }
-    if (group === "silence" && action === "apply") {
-        const result = await context.client.silence.apply({
+    if (group === "effects" && action === "mask" && subaction === "add") {
+        const result = await context.client.effects.mask.add({
             projectId: requireStringFlag({
                 flags: context.args.flags,
                 name: "project-id",
             }),
-            timelineItemId: requireStringFlag({
+            timelineItemId: getStringFlag({
                 flags: context.args.flags,
                 name: "timeline-item-id",
             }),
-            paddingMs: getNumberFlag({
+            contentItemId: getStringFlag({
                 flags: context.args.flags,
-                name: "padding-ms",
+                name: "content-item-id",
             }),
-            silenceThresholdDb: getNumberFlag({
+            effectId: getStringFlag({
                 flags: context.args.flags,
-                name: "silence-threshold-db",
+                name: "effect-id",
             }),
-            minSilenceDurationSeconds: getNumberFlag({
+            name: getStringFlag({ flags: context.args.flags, name: "name" }),
+            startTimeSeconds: getTimelineStartFlag({ flags: context.args.flags }),
+            durationSeconds: getNumberFlag({
                 flags: context.args.flags,
-                name: "min-silence-duration",
+                name: "duration",
             }),
-            removeBlipsMaxDurationSeconds: getNumberFlag({
-                flags: context.args.flags,
-                name: "remove-blips-max-duration",
+            easing: parseEffectEasing({
+                value: getStringFlag({ flags: context.args.flags, name: "easing" }),
             }),
-            useCaptionValidation: getOptionalBooleanFlag({
+            layerIndex: getNumberFlag({
                 flags: context.args.flags,
-                name: "use-caption-validation",
+                name: "layer-index",
             }),
-            deleteSilentClips: getOptionalBooleanFlag({
+            orderIndex: getNumberFlag({
                 flags: context.args.flags,
-                name: "delete-silent-clips",
+                name: "order-index",
             }),
-            manualSegmentOverrides: parseStringRecordFlag({
+            settings: parseJsonObjectFlag({
                 flags: context.args.flags,
-                name: "manual-segment-overrides-json",
+                name: "settings-json",
             }),
-            previewConfirmed: requireConfirmPreview({ flags: context.args.flags }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: [JSON.stringify(result, null, 2)],
+            human: [`Mask effect added: ${result.timeline_item_id}`],
         });
         return;
     }
-    if (group === "mistakes" && action === "plan") {
-        const result = await context.client.mistakes.plan({
+    if (group === "effects" && action === "mask" && subaction === "update") {
+        const result = await context.client.effects.mask.update({
             projectId: requireStringFlag({
                 flags: context.args.flags,
                 name: "project-id",
@@ -1425,450 +1250,2566 @@ async function runCommand({ context }) {
                 flags: context.args.flags,
                 name: "timeline-item-id",
             }),
+            durationSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "duration",
+            }),
+            easing: parseEffectEasing({
+                value: getStringFlag({ flags: context.args.flags, name: "easing" }),
+            }),
+            settings: parseJsonObjectFlag({
+                flags: context.args.flags,
+                name: "settings-json",
+            }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: [JSON.stringify(result, null, 2)],
+            human: [`Mask effect updated: ${result.timeline_item_id}`],
         });
         return;
     }
-    if (group === "mistakes" && action === "apply") {
-        const result = await context.client.mistakes.apply({
+    if (group === "effects" && action === "colorgrade" && subaction === "add") {
+        const result = await context.client.effects.colorgrade.add({
             projectId: requireStringFlag({
                 flags: context.args.flags,
                 name: "project-id",
             }),
-            timelineItemId: requireStringFlag({
+            timelineItemId: getStringFlag({
                 flags: context.args.flags,
                 name: "timeline-item-id",
             }),
-            plan: parseJsonObjectFlag({
+            contentItemId: getStringFlag({
                 flags: context.args.flags,
-                name: "plan-json",
+                name: "content-item-id",
             }),
-            manualVerdicts: parseStringRecordFlag({
+            effectId: getStringFlag({
                 flags: context.args.flags,
-                name: "manual-verdicts-json",
+                name: "effect-id",
             }),
-            deleteMistakes: getOptionalBooleanFlag({
+            name: getStringFlag({ flags: context.args.flags, name: "name" }),
+            startTimeSeconds: getTimelineStartFlag({ flags: context.args.flags }),
+            durationSeconds: getNumberFlag({
                 flags: context.args.flags,
-                name: "delete-mistakes",
+                name: "duration",
+            }),
+            easing: parseEffectEasing({
+                value: getStringFlag({ flags: context.args.flags, name: "easing" }),
+            }),
+            layerIndex: getNumberFlag({
+                flags: context.args.flags,
+                name: "layer-index",
+            }),
+            orderIndex: getNumberFlag({
+                flags: context.args.flags,
+                name: "order-index",
+            }),
+            settings: parseJsonObjectFlag({
+                flags: context.args.flags,
+                name: "settings-json",
             }),
-            previewConfirmed: requireConfirmPreview({ flags: context.args.flags }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: [JSON.stringify(result, null, 2)],
+            human: [`Color grade effect added: ${result.timeline_item_id}`],
         });
         return;
     }
-    if (group === "captions" && action === "words" && subaction === "list") {
-        const result = await context.client.captions.listWords({
+    if (group === "effects" &&
+        action === "colorgrade" &&
+        subaction === "update") {
+        const result = await context.client.effects.colorgrade.update({
             projectId: requireStringFlag({
                 flags: context.args.flags,
                 name: "project-id",
             }),
-            timelineItemId: getStringFlag({
+            timelineItemId: requireStringFlag({
                 flags: context.args.flags,
                 name: "timeline-item-id",
             }),
-            matchText: getStringFlag({
+            durationSeconds: getNumberFlag({
                 flags: context.args.flags,
-                name: "match-text",
+                name: "duration",
+            }),
+            easing: parseEffectEasing({
+                value: getStringFlag({ flags: context.args.flags, name: "easing" }),
+            }),
+            settings: parseJsonObjectFlag({
+                flags: context.args.flags,
+                name: "settings-json",
             }),
-            limit: getNumberFlag({ flags: context.args.flags, name: "limit" }),
-            offset: getNumberFlag({ flags: context.args.flags, name: "offset" }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: result.words.map((word) => JSON.stringify(word)),
+            human: [`Color grade effect updated: ${result.timeline_item_id}`],
         });
         return;
     }
-    if (group === "captions" && action === "words" && subaction === "text") {
-        const result = await context.client.captions.updateWordText({
+    if (group === "audio" && action === "add") {
+        const result = await context.client.audio.add({
             projectId: requireStringFlag({
                 flags: context.args.flags,
                 name: "project-id",
             }),
-            wordId: requireStringFlag({ flags: context.args.flags, name: "word-id" }),
-            newText: getStringFlag({ flags: context.args.flags, name: "new-text" }) ??
-                requireStringFlag({ flags: context.args.flags, name: "text" }),
+            assetId: requireStringFlag({
+                flags: context.args.flags,
+                name: "asset-id",
+            }),
+            startSeconds: parseTimecode({
+                value: getStringFlag({ flags: context.args.flags, name: "at" }) ?? "0",
+            }),
+            durationSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "duration",
+            }),
+            volume: getNumberFlag({ flags: context.args.flags, name: "volume" }),
+            fadeInSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "fade-in",
+            }),
+            fadeOutSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "fade-out",
+            }),
+            loop: getOptionalBooleanFlag({ flags: context.args.flags, name: "loop" }),
         });
         printResult({
             json: context.json,
             value: result,
             human: [
-                `Updated ${result.word_id}: ${result.old_text} -> ${result.new_text}`,
+                `Inserted ${result.summary.inserted}/${result.summary.total} audio item(s).`,
             ],
         });
         return;
     }
-    if (group === "captions" &&
-        action === "words" &&
-        subaction === "batch-text") {
-        const result = await context.client.captions.batchUpdateWordText({
+    if (group === "audio" && action === "update") {
+        const result = await context.client.audio.update({
             projectId: requireStringFlag({
                 flags: context.args.flags,
                 name: "project-id",
             }),
-            updates: parseWordTextUpdatesFlag({
+            timelineItemId: requireStringFlag({
                 flags: context.args.flags,
-                name: "updates-json",
+                name: "timeline-item-id",
             }),
-        });
-        printResult({
-            json: context.json,
-            value: result,
-            human: [result.message],
-        });
-        return;
-    }
-    if (group === "captions" && action === "words" && subaction === "style") {
-        const styleJson = parseNullableJsonObjectFlag({
-            flags: context.args.flags,
-            name: "style-json",
-        });
-        const style = styleJson === undefined
-            ? buildCaptionWordStyleFromFlags({ flags: context.args.flags })
-            : styleJson;
-        const result = await context.client.captions.setWordStyle({
-            ...buildCaptionWordSelector({ flags: context.args.flags }),
-            style,
-            clearExisting: getOptionalBooleanFlag({
+            durationSeconds: getNumberFlag({
                 flags: context.args.flags,
-                name: "clear-existing",
+                name: "duration",
+            }),
+            volume: getNumberFlag({ flags: context.args.flags, name: "volume" }),
+            fadeInSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "fade-in",
+            }),
+            fadeOutSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "fade-out",
             }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: [`Updated ${result.updated_count} caption word(s).`],
+            human: [`Audio updated: ${result.timeline_item_id}`],
         });
         return;
     }
-    if (group === "captions" && action === "words" && subaction === "emphasis") {
-        const result = await context.client.captions.setWordEmphasis({
-            ...buildCaptionWordSelector({ flags: context.args.flags }),
-            emphasis: getOptionalBooleanFlag({
+    if (group === "audio" && action === "search") {
+        const result = await context.client.audioLibrary.search({
+            query: requireStringFlag({ flags: context.args.flags, name: "query" }),
+            provider: parseAudioLibraryProviderFilter({
+                value: getStringFlag({ flags: context.args.flags, name: "provider" }),
+            }),
+            license: parseAudioLibraryLicense({
+                value: getStringFlag({ flags: context.args.flags, name: "license" }),
+            }),
+            audioType: parseAudioLibraryType({
+                value: getStringFlag({ flags: context.args.flags, name: "audio-type" }),
+            }),
+            minDurationSeconds: getNumberFlag({
                 flags: context.args.flags,
-                name: "emphasis",
-            }) ?? true,
+                name: "min-duration",
+            }),
+            maxDurationSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "max-duration",
+            }),
+            limit: getNumberFlag({ flags: context.args.flags, name: "limit" }),
+            page: getNumberFlag({ flags: context.args.flags, name: "page" }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: [`Updated ${result.updated_count} caption word(s).`],
+            human: [
+                ...result.warnings.map((warning) => `Warning: ${warning}`),
+                ...result.items.map((item) => `${item.provider}:${item.external_id} ${item.title} ${item.duration_seconds ?? "-"}s ${item.license_code}`),
+            ],
         });
         return;
     }
-    if (group === "captions" && action === "words" && subaction === "delete") {
-        const result = await context.client.captions.deleteWords({
-            projectId: requireStringFlag({
+    if (group === "audio" && action === "import") {
+        const result = await context.client.audioLibrary.importAsset({
+            provider: parseAudioLibraryProvider({
+                value: requireStringFlag({
+                    flags: context.args.flags,
+                    name: "provider",
+                }),
+            }),
+            externalId: requireStringFlag({
+                flags: context.args.flags,
+                name: "external-id",
+            }),
+            folderId: parseFolderIdFlag({
+                flags: context.args.flags,
+                name: "folder-id",
+            }),
+            projectId: getStringFlag({
                 flags: context.args.flags,
                 name: "project-id",
             }),
-            wordIds: parseWordIds({ flags: context.args.flags }),
+            startSeconds: parseTimecode({
+                value: getStringFlag({ flags: context.args.flags, name: "at" }) ?? "0",
+            }),
+            durationSeconds: parseNullableNumberFlag({
+                flags: context.args.flags,
+                name: "duration",
+            }),
+            volume: getNumberFlag({ flags: context.args.flags, name: "volume" }),
+            fadeInSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "fade-in",
+            }),
+            fadeOutSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "fade-out",
+            }),
+            loop: getOptionalBooleanFlag({ flags: context.args.flags, name: "loop" }),
+            audioType: parseAudioLibraryType({
+                value: getStringFlag({ flags: context.args.flags, name: "audio-type" }),
+            }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: [result.message],
+            human: [
+                `${result.imported ? "Imported" : "Reused"} ${result.asset.name} (${result.asset.id}).`,
+                result.timeline_item_id
+                    ? `Inserted on timeline as ${result.timeline_item_id}.`
+                    : "No timeline insert requested.",
+            ],
         });
         return;
     }
-    if (group === "captions" && action === "words" && subaction === "merge") {
-        const result = await context.client.captions.mergeWords({
-            projectId: requireStringFlag({
-                flags: context.args.flags,
-                name: "project-id",
+    if (group === "stock" && action === "search") {
+        const result = await context.client.stockMedia.search({
+            query: requireStringFlag({ flags: context.args.flags, name: "query" }),
+            assetType: parseStockAssetType({
+                value: requireStringFlag({
+                    flags: context.args.flags,
+                    name: "asset-type",
+                }),
             }),
-            wordIds: parseWordIds({ flags: context.args.flags }),
-            text: getStringFlag({ flags: context.args.flags, name: "text" }),
+            provider: parseStockProvider({
+                value: getStringFlag({ flags: context.args.flags, name: "provider" }),
+            }),
+            orientation: parseStockOrientation({
+                value: getStringFlag({
+                    flags: context.args.flags,
+                    name: "orientation",
+                }),
+            }),
+            limit: getNumberFlag({ flags: context.args.flags, name: "limit" }),
+            page: getNumberFlag({ flags: context.args.flags, name: "page" }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: [result.message],
+            human: [
+                ...result.warnings.map((warning) => `Warning: ${warning}`),
+                ...result.items.map((item) => `${item.provider}:${item.provider_asset_id} ${item.asset_type} ${item.title} ${item.duration_seconds ?? "-"}s ${item.license_code}`),
+            ],
         });
         return;
     }
-    if (group === "captions" && action === "words" && subaction === "split") {
-        const result = await context.client.captions.splitWord({
-            projectId: requireStringFlag({
+    if (group === "stock" && action === "import") {
+        const result = await context.client.stockMedia.importAsset({
+            provider: parseRequiredStockProvider({
+                value: requireStringFlag({
+                    flags: context.args.flags,
+                    name: "provider",
+                }),
+            }),
+            providerAssetId: requireStringFlag({
                 flags: context.args.flags,
-                name: "project-id",
+                name: "provider-asset-id",
+            }),
+            assetType: parseStockAssetType({
+                value: requireStringFlag({
+                    flags: context.args.flags,
+                    name: "asset-type",
+                }),
+            }),
+            variantId: parseNullableStringFlag({
+                flags: context.args.flags,
+                name: "variant-id",
+            }),
+            folderId: parseFolderIdFlag({
+                flags: context.args.flags,
+                name: "folder-id",
+            }),
+            audioType: parseStockAudioType({
+                value: getStringFlag({ flags: context.args.flags, name: "audio-type" }),
             }),
-            wordId: requireStringFlag({ flags: context.args.flags, name: "word-id" }),
-            words: parseCsvRequiredFlag({ flags: context.args.flags, name: "words" }),
-        });
-        printResult({
-            json: context.json,
-            value: result,
-            human: [result.message],
         });
-        return;
-    }
-    if (group === "captions" && action === "themes" && subaction === "list") {
-        const result = await context.client.captions.listThemes();
         printResult({
             json: context.json,
             value: result,
-            human: result.themes.map((theme) => JSON.stringify(theme)),
+            human: [
+                `${result.imported ? "Imported" : "Reused"} ${result.asset.name} (${result.asset.id}).`,
+            ],
         });
         return;
     }
-    if (group === "captions" && action === "theme" && subaction === "set") {
-        const result = await context.client.captions.setProjectTheme({
-            projectId: requireStringFlag({
-                flags: context.args.flags,
-                name: "project-id",
+    if (group === "library" && action === "search") {
+        const result = await context.client.library.search({
+            query: getStringFlag({ flags: context.args.flags, name: "query" }),
+            assetType: parseNullableStockAssetType({
+                value: getStringFlag({
+                    flags: context.args.flags,
+                    name: "asset-type",
+                }),
             }),
-            themeId: requireStringFlag({
-                flags: context.args.flags,
-                name: "theme-id",
+            audioType: parseGlobalBrollAudioType({
+                value: getStringFlag({ flags: context.args.flags, name: "audio-type" }),
             }),
+            limit: getNumberFlag({ flags: context.args.flags, name: "limit" }),
+            offset: getNumberFlag({ flags: context.args.flags, name: "offset" }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: ["Project caption theme updated."],
+            human: result.items.map((item) => `${item.id} ${item.asset_type} ${item.title} ${item.duration_seconds ?? "-"}s ${item.license_code}`),
         });
         return;
     }
-    if (group === "captions" &&
-        action === "theme" &&
-        subaction === "set-default") {
-        const result = await context.client.captions.setDefaultTheme({
-            themeId: requireStringFlag({
+    if (group === "library" && action === "import") {
+        const result = await context.client.library.importAsset({
+            libraryAssetId: requireStringFlag({
                 flags: context.args.flags,
-                name: "theme-id",
+                name: "library-asset-id",
+            }),
+            folderId: parseFolderIdFlag({
+                flags: context.args.flags,
+                name: "folder-id",
             }),
         });
         printResult({
             json: context.json,
             value: result,
-            human: ["Default caption theme updated."],
+            human: [
+                `${result.imported ? "Imported" : "Reused"} ${result.asset.name} (${result.asset.id}).`,
+            ],
         });
         return;
     }
-    if (group === "exports" && action === "start") {
-        const result = await context.client.exports.start({
+    if (group === "silence" && action === "plan") {
+        const result = await context.client.silence.plan({
             projectId: requireStringFlag({
                 flags: context.args.flags,
                 name: "project-id",
             }),
-            resolution: getStringFlag({
+            timelineItemId: requireStringFlag({
+                flags: context.args.flags,
+                name: "timeline-item-id",
+            }),
+            allMediaItems: undefined,
+            paddingMs: getNumberFlag({
                 flags: context.args.flags,
-                name: "resolution",
+                name: "padding-ms",
             }),
-            format: getStringFlag({ flags: context.args.flags, name: "format" }),
-            includeCaptions: getOptionalBooleanFlag({
+            silenceThresholdDb: getNumberFlag({
                 flags: context.args.flags,
-                name: "include-captions",
+                name: "silence-threshold-db",
             }),
-        });
-        printResult({
-            json: context.json,
-            value: result,
-            human: [`Export queued: ${result.export_id ?? result.job_id}`],
-        });
-        return;
-    }
-    if (group === "exports" && action === "wait") {
-        const result = await context.client.exports.wait({
-            exportId: requireStringFlag({
+            minSilenceDurationSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "min-silence-duration",
+            }),
+            removeBlipsMaxDurationSeconds: getNumberFlag({
                 flags: context.args.flags,
-                name: "export-id",
+                name: "remove-blips-max-duration",
+            }),
+            useCaptionValidation: getOptionalBooleanFlag({
+                flags: context.args.flags,
+                name: "use-caption-validation",
             }),
-            intervalMs: getNumberFlag({ flags: context.args.flags, name: "interval-ms" }) ??
-                DEFAULT_WAIT_INTERVAL_MS,
-            timeoutMs: getNumberFlag({ flags: context.args.flags, name: "timeout-ms" }) ??
-                DEFAULT_WAIT_TIMEOUT_MS,
         });
         printResult({
             json: context.json,
             value: result,
-            human: [
-                `Export ready: ${result.download_url ?? result.short_download_url ?? result.export_id}`,
-            ],
+            human: [JSON.stringify(result, null, 2)],
         });
         return;
     }
-    if (group === "exports" && action === "download") {
-        const output = requireStringFlag({
+    if (group === "silence" && action === "apply") {
+        const allMediaItems = getOptionalBooleanFlag({
             flags: context.args.flags,
-            name: "output",
-        });
-        const bytes = await context.client.exports.download({
-            exportId: requireStringFlag({
+            name: "all-media-items",
+        }) ?? false;
+        const result = await context.client.silence.apply({
+            projectId: requireStringFlag({
                 flags: context.args.flags,
-                name: "export-id",
+                name: "project-id",
             }),
-        });
-        await writeFile(resolve(output), Buffer.from(bytes));
-        printResult({
-            json: context.json,
-            value: { output },
-            human: [`Downloaded export: ${output}`],
-        });
-        return;
-    }
-    throw buildUnknownCommandError({ command: context.args.command });
-}
-async function setApiKey({ context }) {
-    const apiKey = getStringFlag({ flags: context.args.flags, name: "api-key" }) ??
-        process.env.BLITZREELS_API_KEY;
-    if (!apiKey) {
-        throw new Error("Pass --api-key or set BLITZREELS_API_KEY.");
-    }
-    const savedToKeychain = await saveApiKey({ apiKey });
-    const config = {
-        apiKey: savedToKeychain ? "" : apiKey,
-        baseUrl: getStringFlag({ flags: context.args.flags, name: "base-url" }),
-        keyStorage: savedToKeychain ? "keychain" : "config",
-    };
-    await mkdir(dirname(CONFIG_PATH), { recursive: true });
-    await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), {
-        mode: 0o600,
-    });
-    printResult({
-        json: context.json,
-        value: { configPath: CONFIG_PATH },
-        human: [`API key saved to ${CONFIG_PATH}`],
+            timelineItemId: allMediaItems
+                ? undefined
+                : requireStringFlag({
+                    flags: context.args.flags,
+                    name: "timeline-item-id",
+                }),
+            allMediaItems,
+            paddingMs: getNumberFlag({
+                flags: context.args.flags,
+                name: "padding-ms",
+            }),
+            silenceThresholdDb: getNumberFlag({
+                flags: context.args.flags,
+                name: "silence-threshold-db",
+            }),
+            minSilenceDurationSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "min-silence-duration",
+            }),
+            removeBlipsMaxDurationSeconds: getNumberFlag({
+                flags: context.args.flags,
+                name: "remove-blips-max-duration",
+            }),
+            useCaptionValidation: getOptionalBooleanFlag({
+                flags: context.args.flags,
+                name: "use-caption-validation",
+            }),
+            deleteSilentClips: getOptionalBooleanFlag({
+                flags: context.args.flags,
+                name: "delete-silent-clips",
+            }),
+            manualSegmentOverrides: parseStringRecordFlag({
+                flags: context.args.flags,
+                name: "manual-segment-overrides-json",
+            }),
+            previewConfirmed: requirePreviewFirstConfirmation({
+                confirmed: getBooleanFlag({
+                    flags: context.args.flags,
+                    name: "confirm-preview",
+                }),
+            }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [JSON.stringify(result, null, 2)],
+        });
+        return;
+    }
+    if (group === "mistakes" && action === "plan") {
+        const result = await context.client.mistakes.plan({
+            projectId: requireStringFlag({
+                flags: context.args.flags,
+                name: "project-id",
+            }),
+            timelineItemId: requireStringFlag({
+                flags: context.args.flags,
+                name: "timeline-item-id",
+            }),
+        });
+        const value = getBooleanFlag({
+            flags: context.args.flags,
+            name: "summary",
+        })
+            ? summarizeMistakePlan({ plan: result })
+            : result;
+        printResult({
+            json: context.json,
+            value,
+            human: [JSON.stringify(value, null, 2)],
+        });
+        return;
+    }
+    if (group === "mistakes" && action === "apply") {
+        const result = await context.client.mistakes.apply({
+            projectId: requireStringFlag({
+                flags: context.args.flags,
+                name: "project-id",
+            }),
+            timelineItemId: requireStringFlag({
+                flags: context.args.flags,
+                name: "timeline-item-id",
+            }),
+            plan: parseJsonObjectFlag({
+                flags: context.args.flags,
+                name: "plan-json",
+            }),
+            manualVerdicts: parseStringRecordFlag({
+                flags: context.args.flags,
+                name: "manual-verdicts-json",
+            }),
+            deleteMistakes: getOptionalBooleanFlag({
+                flags: context.args.flags,
+                name: "delete-mistakes",
+            }),
+            previewConfirmed: requirePreviewFirstConfirmation({
+                confirmed: getBooleanFlag({
+                    flags: context.args.flags,
+                    name: "confirm-preview",
+                }),
+            }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [JSON.stringify(result, null, 2)],
+        });
+        return;
+    }
+    if (group === "captions" &&
+        ((action === "words" && subaction === "list") || action === "list-words")) {
+        const result = await context.client.captions.listWords({
+            projectId: requireStringFlag({
+                flags: context.args.flags,
+                name: "project-id",
+            }),
+            timelineItemId: getStringFlag({
+                flags: context.args.flags,
+                name: "timeline-item-id",
+            }),
+            matchText: getStringFlag({
+                flags: context.args.flags,
+                name: "match-text",
+            }),
+            limit: getNumberFlag({ flags: context.args.flags, name: "limit" }),
+            offset: getNumberFlag({ flags: context.args.flags, name: "offset" }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: result.words.map((word) => JSON.stringify(word)),
+        });
+        return;
+    }
+    if (group === "captions" &&
+        (action === "delete" || action === "hide" || action === "show")) {
+        const selector = buildCaptionTrackSelector({ flags: context.args.flags });
+        const result = action === "delete"
+            ? await context.client.captions.delete(selector)
+            : action === "hide"
+                ? await context.client.captions.hide(selector)
+                : await context.client.captions.show(selector);
+        printResult({
+            json: context.json,
+            value: result,
+            human: [result.message],
+        });
+        return;
+    }
+    if (group === "captions" && action === "words" && subaction === "text") {
+        const result = await context.client.captions.updateWordText({
+            projectId: requireStringFlag({
+                flags: context.args.flags,
+                name: "project-id",
+            }),
+            wordId: requireStringFlag({ flags: context.args.flags, name: "word-id" }),
+            newText: getStringFlag({ flags: context.args.flags, name: "new-text" }) ??
+                requireStringFlag({ flags: context.args.flags, name: "text" }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [
+                `Updated ${result.word_id}: ${result.old_text} -> ${result.new_text}`,
+            ],
+        });
+        return;
+    }
+    if (group === "captions" &&
+        action === "words" &&
+        subaction === "batch-text") {
+        const result = await context.client.captions.batchUpdateWordText({
+            projectId: requireStringFlag({
+                flags: context.args.flags,
+                name: "project-id",
+            }),
+            updates: parseWordTextUpdatesFlag({
+                flags: context.args.flags,
+                name: "updates-json",
+            }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [result.message],
+        });
+        return;
+    }
+    if (group === "captions" &&
+        ((action === "words" && subaction === "style") || action === "style-words")) {
+        const styleJson = parseNullableJsonObjectFlag({
+            flags: context.args.flags,
+            name: "style-json",
+        });
+        const style = styleJson === undefined
+            ? buildCaptionWordStyleFromFlags({ flags: context.args.flags })
+            : styleJson;
+        const result = await context.client.captions.setWordStyle({
+            ...buildCaptionWordSelector({ flags: context.args.flags }),
+            style,
+            clearExisting: getOptionalBooleanFlag({
+                flags: context.args.flags,
+                name: "clear-existing",
+            }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [`Updated ${result.updated_count} caption word(s).`],
+        });
+        return;
+    }
+    if (group === "captions" &&
+        ((action === "words" && subaction === "emphasis") || action === "emphasize")) {
+        const result = await context.client.captions.setWordEmphasis({
+            ...buildCaptionWordSelector({ flags: context.args.flags }),
+            emphasis: getOptionalBooleanFlag({
+                flags: context.args.flags,
+                name: "emphasis",
+            }) ?? true,
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [`Updated ${result.updated_count} caption word(s).`],
+        });
+        return;
+    }
+    if (group === "captions" && action === "words" && subaction === "delete") {
+        const result = await context.client.captions.deleteWords({
+            projectId: requireStringFlag({
+                flags: context.args.flags,
+                name: "project-id",
+            }),
+            wordIds: parseWordIds({ flags: context.args.flags }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [result.message],
+        });
+        return;
+    }
+    if (group === "captions" && action === "words" && subaction === "merge") {
+        const result = await context.client.captions.mergeWords({
+            projectId: requireStringFlag({
+                flags: context.args.flags,
+                name: "project-id",
+            }),
+            wordIds: parseWordIds({ flags: context.args.flags }),
+            text: getStringFlag({ flags: context.args.flags, name: "text" }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [result.message],
+        });
+        return;
+    }
+    if (group === "captions" && action === "words" && subaction === "split") {
+        const result = await context.client.captions.splitWord({
+            projectId: requireStringFlag({
+                flags: context.args.flags,
+                name: "project-id",
+            }),
+            wordId: requireStringFlag({ flags: context.args.flags, name: "word-id" }),
+            words: parseCsvRequiredFlag({ flags: context.args.flags, name: "words" }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: [result.message],
+        });
+        return;
+    }
+    if (group === "captions" && action === "themes" && subaction === "list") {
+        const result = await context.client.captions.listThemes();
+        printResult({
+            json: context.json,
+            value: result,
+            human: result.themes.length > 0
+                ? result.themes.map((theme) => JSON.stringify(theme))
+                : [
+                    "No custom caption themes yet.",
+                    "Create one in the dashboard, then use `blitzreels captions theme set --project-id ID --theme-id ID` or `blitzreels captions theme set-default --theme-id ID`.",
+                ],
+        });
+        return;
+    }
+    if (group === "captions" && action === "theme" && subaction === "set") {
+        const result = await context.client.captions.setProjectTheme({
+            projectId: requireStringFlag({
+                flags: context.args.flags,
+                name: "project-id",
+            }),
+            themeId: requireStringFlag({
+                flags: context.args.flags,
+                name: "theme-id",
+            }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: ["Project caption theme updated."],
+        });
+        return;
+    }
+    if (group === "captions" && action === "theme" && subaction === "update") {
+        const result = await context.client.captions.updateTheme({
+            themeId: requireStringFlag({
+                flags: context.args.flags,
+                name: "theme-id",
+            }),
+            name: getStringFlag({ flags: context.args.flags, name: "name" }),
+            description: getStringFlag({
+                flags: context.args.flags,
+                name: "description",
+            }),
+            settings: buildCaptionThemeSettingsPatch({ flags: context.args.flags }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: ["Caption theme updated."],
+        });
+        return;
+    }
+    if (group === "captions" &&
+        action === "theme" &&
+        subaction === "set-default") {
+        const result = await context.client.captions.setDefaultTheme({
+            themeId: requireStringFlag({
+                flags: context.args.flags,
+                name: "theme-id",
+            }),
+        });
+        printResult({
+            json: context.json,
+            value: result,
+            human: ["Default caption theme updated."],
+        });
+        return;
+    }
+    if (group === "exports") {
+        const handled = await handleExportsCommand({
+            context,
+            action,
+            helpers: {
+                getNumberFlag,
+                getOptionalBooleanFlag,
+                getStringFlag,
+                requireStringFlag,
+                printResult,
+            },
+            defaultWaitIntervalMs: DEFAULT_WAIT_INTERVAL_MS,
+            defaultWaitTimeoutMs: DEFAULT_WAIT_TIMEOUT_MS,
+        });
+        if (handled) {
+            return;
+        }
+    }
+    throw buildUnknownCommandError({ command: context.args.command });
+}
+async function setApiKey({ context }) {
+    const apiKey = getStringFlag({ flags: context.args.flags, name: "api-key" }) ??
+        process.env.BLITZREELS_API_KEY;
+    if (!apiKey) {
+        throw new Error("Pass --api-key or set BLITZREELS_API_KEY.");
+    }
+    const stored = await storeApiKey({
+        apiKey,
+        baseUrl: getStringFlag({ flags: context.args.flags, name: "base-url" }),
+    });
+    printResult({
+        json: context.json,
+        value: { configPath: stored.configPath, keyStorage: stored.keyStorage },
+        human: [`API key saved to ${stored.configPath}`],
+    });
+}
+async function loginWithBrowser({ context, }) {
+    const appUrl = resolveAppUrl({ baseUrl: context.config.baseUrl });
+    const deviceUrl = `${appUrl}/api/cli/auth/device`;
+    const startResponse = await fetch(deviceUrl, {
+        method: "POST",
+        headers: { Accept: "application/json" },
+    });
+    const login = parseDeviceLoginResponse({
+        value: await readJsonResponse({
+            response: startResponse,
+            url: deviceUrl,
+            action: "start CLI login",
+        }),
+    });
+    const shouldOpenBrowser = !getBooleanFlag({
+        flags: context.args.flags,
+        name: "no-browser",
+    });
+    if (shouldOpenBrowser) {
+        openBrowser({ url: login.verification_uri_complete });
+    }
+    const loginInstructions = [
+        `First copy your one-time code: ${login.user_code}`,
+        `Then open: ${login.verification_uri_complete}`,
+        "Waiting for browser approval...",
+    ];
+    if (context.json) {
+        console.error(loginInstructions.join("\n"));
+    }
+    else {
+        printResult({
+            json: context.json,
+            value: {
+                user_code: login.user_code,
+                verification_uri: login.verification_uri_complete,
+                expires_in: login.expires_in,
+            },
+            human: loginInstructions,
+        });
+    }
+    const startedAt = Date.now();
+    const timeoutMs = Math.min(login.expires_in * 1000, getNumberFlag({ flags: context.args.flags, name: "timeout-ms" }) ??
+        login.expires_in * 1000);
+    const intervalMs = Math.max(1000, login.interval * 1000);
+    while (Date.now() - startedAt <= timeoutMs) {
+        await sleep({ ms: intervalMs });
+        const tokenUrl = `${appUrl}/api/cli/auth/token`;
+        const pollResponse = await fetch(tokenUrl, {
+            method: "POST",
+            headers: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ device_code: login.device_code }),
+        });
+        const result = parseDeviceTokenResponse({
+            value: await readJsonResponse({
+                response: pollResponse,
+                url: tokenUrl,
+                action: "poll CLI login",
+            }),
+        });
+        if (result.status === "approved" && result.api_key) {
+            await persistLoggedInApiKey({
+                apiKey: result.api_key,
+                baseUrl: context.config.baseUrl,
+            });
+            printResult({
+                json: context.json,
+                value: { success: true, key_prefix: result.key_prefix ?? "" },
+                human: [`Logged in. API key prefix: ${result.key_prefix ?? "saved"}`],
+            });
+            return;
+        }
+        if (result.status === "expired" ||
+            result.status === "denied" ||
+            result.status === "invalid" ||
+            result.status === "consumed") {
+            throw new Error(`Login failed: ${result.status}.`);
+        }
+    }
+    throw new Error("Timed out waiting for browser approval.");
+}
+async function uploadMediaFile({ context }) {
+    const filePath = resolve(requireStringFlag({ flags: context.args.flags, name: "file" }));
+    const fileStats = await stat(filePath);
+    if (!fileStats.isFile()) {
+        throw new Error(`Not a file: ${filePath}`);
+    }
+    const fileName = getStringFlag({ flags: context.args.flags, name: "name" }) ??
+        basename(filePath);
+    const contentType = getStringFlag({ flags: context.args.flags, name: "content-type" }) ??
+        inferContentType({ filePath });
+    const autoJobs = buildUploadAutoJobNotice({ flags: context.args.flags });
+    if (autoJobs.length > 0) {
+        console.error(`BlitzReels upload will queue background jobs: ${autoJobs.join(", ")}. Use \`blitzreels media wait --asset-id ID --for all\` after upload when you need processed metadata.`);
+    }
+    const init = await context.client.media.initUpload({
+        fileName,
+        contentType,
+    });
+    const bytes = await readFile(filePath);
+    const uploadResponse = await fetch(init.upload_url, {
+        method: "PUT",
+        headers: { "Content-Type": contentType },
+        body: new Blob([new Uint8Array(bytes)], { type: contentType }),
+    });
+    if (!uploadResponse.ok) {
+        throw new Error(`Upload failed with ${uploadResponse.status}: ${await uploadResponse.text()}`);
+    }
+    return context.client.media.finalizeUpload({
+        storageKey: init.storage_key,
+        fileName,
+        contentType,
+        fileSizeBytes: fileStats.size,
+        autoProcessEnabled: getOptionalBooleanFlag({
+            flags: context.args.flags,
+            name: "auto-process",
+        }),
+        autoTranscribe: getOptionalBooleanFlag({
+            flags: context.args.flags,
+            name: "auto-transcribe",
+        }),
+        autoDescribeAfterTranscribe: getOptionalBooleanFlag({
+            flags: context.args.flags,
+            name: "auto-describe",
+        }),
+        autoSuggestShorts: getOptionalBooleanFlag({
+            flags: context.args.flags,
+            name: "auto-suggest-shorts",
+        }),
+    });
+}
+async function waitForMediaAsset({ context, }) {
+    const assetId = requireStringFlag({
+        flags: context.args.flags,
+        name: "asset-id",
+    });
+    const projectId = getStringFlag({
+        flags: context.args.flags,
+        name: "project-id",
+    });
+    const waitFor = parseMediaWaitFor({
+        value: getStringFlag({ flags: context.args.flags, name: "for" }),
+    });
+    const intervalMs = getNumberFlag({ flags: context.args.flags, name: "interval-ms" }) ??
+        DEFAULT_WAIT_INTERVAL_MS;
+    const timeoutMs = getNumberFlag({ flags: context.args.flags, name: "timeout-ms" }) ??
+        10 * 60 * 1000;
+    const startedAt = Date.now();
+    let lastAsset;
+    while (true) {
+        const result = await context.client.media.get({ assetId });
+        lastAsset = result.asset;
+        const clippingStatus = await context.client.media.clippingStatus({
+            assetId,
+            projectId,
+        });
+        const readyFor = getReadyMediaStates({
+            asset: lastAsset,
+            clippingStatus,
+        });
+        if (mediaWaitSatisfied({ readyFor, waitFor })) {
+            return {
+                asset: {
+                    id: lastAsset.id,
+                    name: lastAsset.name,
+                    processingStatus: lastAsset.processingStatus,
+                    processingSubstage: lastAsset.processingSubstage,
+                    processingError: lastAsset.processingError,
+                    processingErrors: lastAsset.processingErrors,
+                    retryable: lastAsset.retryable,
+                    providerRequestIds: lastAsset.providerRequestIds,
+                    durationSeconds: lastAsset.durationSeconds,
+                    aiDescription: lastAsset.aiDescription,
+                },
+                ready_for: readyFor,
+                waited_ms: Date.now() - startedAt,
+            };
+        }
+        if (Date.now() - startedAt >= timeoutMs) {
+            throw new Error(`Timed out waiting for media asset ${assetId}. Last status: ${lastAsset.processingStatus ?? "unknown"}${lastAsset.processingSubstage ? `/${lastAsset.processingSubstage}` : ""}${lastAsset.processingError ? `: ${lastAsset.processingError}` : ""}.`);
+        }
+        await sleep({ ms: intervalMs });
+    }
+}
+function getClipRecord({ result, }) {
+    return isRecord(result.clip) ? result.clip : {};
+}
+function printClipResult({ context, result, }) {
+    const clip = getClipRecord({ result });
+    const clipId = typeof clip.clip_id === "string" ? clip.clip_id : "unknown";
+    const status = typeof clip.status === "string" ? clip.status : "unknown";
+    const nextAction = typeof clip.next_action === "string" ? clip.next_action : "unknown";
+    const projectId = typeof clip.project_id === "string" ? clip.project_id : null;
+    printResult({
+        json: context.json,
+        value: result,
+        human: [
+            `Clip ${clipId}: ${status}`,
+            `Next action: ${nextAction}`,
+            ...(projectId === null ? [] : [`Project: ${projectId}`]),
+        ],
+    });
+}
+function parseClipSourceType({ value, }) {
+    if (value === "asset" || value === "youtube") {
+        return value;
+    }
+    throw new Error("--source-type must be asset or youtube.");
+}
+function parseClipSelectionMode({ value, }) {
+    if (value === undefined) {
+        return "auto_best";
+    }
+    if (value === "auto_best" ||
+        value === "suggestion" ||
+        value === "time_range") {
+        return value;
+    }
+    throw new Error("--selection-mode must be auto_best, suggestion, or time_range.");
+}
+function parseClipLayoutMode({ value, }) {
+    if (value === undefined) {
+        return "auto";
+    }
+    if (value === "auto" ||
+        value === "prefer_split" ||
+        value === "prefer_focus") {
+        return value;
+    }
+    throw new Error("--layout-mode must be auto, prefer_split, or prefer_focus.");
+}
+function parseClipContentTypeHint({ value, }) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "auto" ||
+        value === "podcast" ||
+        value === "tutorial" ||
+        value === "generic") {
+        return value;
+    }
+    throw new Error("--content-type-hint must be auto, podcast, tutorial, or generic.");
+}
+function parseClipQaMode({ value, }) {
+    if (value === undefined) {
+        return "required";
+    }
+    if (value === "required" || value === "permissive") {
+        return value;
+    }
+    throw new Error("--qa-mode must be required or permissive.");
+}
+function parseClipRepairMode({ value, }) {
+    if (value === undefined) {
+        return "auto";
+    }
+    if (value === "auto" ||
+        value === "prefer_split" ||
+        value === "prefer_focus" ||
+        value === "prefer_tutorial" ||
+        value === "move_captions_off_faces") {
+        return value;
+    }
+    throw new Error("--repair-mode must be auto, prefer_split, prefer_focus, prefer_tutorial, or move_captions_off_faces.");
+}
+function parseClipExportResolution({ value, }) {
+    if (value === undefined) {
+        return "1080p";
+    }
+    if (value === "720p" || value === "1080p") {
+        return value;
+    }
+    throw new Error("--resolution must be 720p or 1080p.");
+}
+function parseClipExportFormat({ value, }) {
+    if (value === undefined) {
+        return "mp4";
+    }
+    if (value === "mp4" || value === "mov") {
+        return value;
+    }
+    throw new Error("--format must be mp4 or mov.");
+}
+function buildClipSource({ flags }) {
+    const sourceType = parseClipSourceType({
+        value: requireStringFlag({ flags, name: "source-type" }),
+    });
+    if (sourceType === "asset") {
+        return {
+            sourceType,
+            assetId: requireStringFlag({ flags, name: "asset-id" }),
+            youtubeUrl: null,
+        };
+    }
+    return {
+        sourceType,
+        assetId: null,
+        youtubeUrl: requireStringFlag({ flags, name: "youtube-url" }),
+    };
+}
+function requireNumberFlag({ flags, name, }) {
+    const value = getNumberFlag({ flags, name });
+    if (value === undefined) {
+        throw new Error(`Missing required --${name}.`);
+    }
+    return value;
+}
+function buildClipSelection({ flags }) {
+    const mode = parseClipSelectionMode({
+        value: getStringFlag({ flags, name: "selection-mode" }),
+    });
+    return {
+        mode,
+        suggestionId: mode === "suggestion"
+            ? requireStringFlag({ flags, name: "suggestion-id" })
+            : (parseNullableStringFlag({ flags, name: "suggestion-id" }) ?? null),
+        startSeconds: mode === "time_range"
+            ? requireNumberFlag({ flags, name: "start-seconds" })
+            : (parseNullableNumberFlag({ flags, name: "start-seconds" }) ?? null),
+        endSeconds: mode === "time_range"
+            ? requireNumberFlag({ flags, name: "end-seconds" })
+            : (parseNullableNumberFlag({ flags, name: "end-seconds" }) ?? null),
+    };
+}
+function buildClipTarget({ flags, requireMaxDuration, }) {
+    const maxDurationSeconds = getNumberFlag({ flags, name: "max-duration" });
+    const minDurationInput = parseNullableNumberFlag({
+        flags,
+        name: "min-duration",
+    });
+    if (maxDurationSeconds === undefined) {
+        if (requireMaxDuration) {
+            throw new Error("Missing required --max-duration.");
+        }
+        if (minDurationInput !== undefined && minDurationInput !== null) {
+            throw new Error("--max-duration is required when --min-duration is set.");
+        }
+        return null;
+    }
+    const minDurationSeconds = minDurationInput ?? null;
+    if (minDurationSeconds !== null && minDurationSeconds > maxDurationSeconds) {
+        throw new Error("--min-duration must be less than or equal to --max-duration.");
+    }
+    return {
+        minDurationSeconds,
+        maxDurationSeconds,
+    };
+}
+function toCreateClipOptions({ flags, }) {
+    const target = buildClipTarget({ flags, requireMaxDuration: true });
+    if (target === null) {
+        throw new Error("Missing required --max-duration.");
+    }
+    return {
+        projectName: parseNullableStringFlag({ flags, name: "name" }) ?? null,
+        source: buildClipSource({ flags }),
+        selection: buildClipSelection({ flags }),
+        target: {
+            aspectRatio: "9:16",
+            ...target,
+        },
+        layout: {
+            mode: parseClipLayoutMode({
+                value: getStringFlag({ flags, name: "layout-mode" }),
+            }),
+            contentTypeHint: parseClipContentTypeHint({
+                value: getStringFlag({ flags, name: "content-type-hint" }),
+            }),
+        },
+        captions: {
+            enabled: getOptionalBooleanFlag({ flags, name: "captions" }) ?? true,
+            styleId: parseNullableStringFlag({ flags, name: "caption-style-id" }) ?? null,
+        },
+        qa: {
+            mode: parseClipQaMode({
+                value: getStringFlag({ flags, name: "qa-mode" }),
+            }),
+        },
+        export: {
+            autoExport: getOptionalBooleanFlag({ flags, name: "auto-export" }) ?? false,
+        },
+    };
+}
+async function waitForClip({ context, }) {
+    const clipId = requireStringFlag({
+        flags: context.args.flags,
+        name: "clip-id",
+    });
+    const intervalMs = getNumberFlag({ flags: context.args.flags, name: "interval-ms" }) ??
+        DEFAULT_WAIT_INTERVAL_MS;
+    const timeoutMs = getNumberFlag({ flags: context.args.flags, name: "timeout-ms" }) ??
+        10 * 60 * 1000;
+    const startedAt = Date.now();
+    while (true) {
+        const result = await context.client.clips.get({ clipId });
+        const clip = getClipRecord({ result });
+        const nextAction = typeof clip.next_action === "string" ? clip.next_action : null;
+        const status = typeof clip.status === "string" ? clip.status : null;
+        if (nextAction !== "poll" || status === "failed" || status === "exported") {
+            return result;
+        }
+        if (Date.now() - startedAt >= timeoutMs) {
+            throw new Error(`Timed out waiting for clip ${clipId}. Last status: ${status ?? "unknown"}.`);
+        }
+        await sleep({ ms: intervalMs });
+    }
+}
+function buildUploadAutoJobNotice({ flags }) {
+    const jobs = [];
+    if (getOptionalBooleanFlag({ flags, name: "auto-process" }) !== false) {
+        jobs.push("process");
+    }
+    if (getOptionalBooleanFlag({ flags, name: "auto-transcribe" }) !== false) {
+        jobs.push("transcribe");
+    }
+    if (getOptionalBooleanFlag({ flags, name: "auto-describe" }) !== false) {
+        jobs.push("describe");
+    }
+    if (getOptionalBooleanFlag({ flags, name: "auto-suggest-shorts" }) !== false) {
+        jobs.push("suggest-shorts");
+    }
+    return jobs;
+}
+function parseMediaWaitFor({ value, }) {
+    if (value === undefined) {
+        return "processing";
+    }
+    if (value === "processing" ||
+        value === "transcription" ||
+        value === "description" ||
+        value === "shorts" ||
+        value === "all") {
+        return value;
+    }
+    throw new Error("--for must be processing, transcription, description, shorts, or all.");
+}
+function getReadyMediaStates({ asset, clippingStatus, }) {
+    const ready = new Set();
+    if (asset.processingStatus === "completed" ||
+        asset.durationSeconds !== null) {
+        ready.add("processing");
+    }
+    const readiness = isRecord(clippingStatus.readiness)
+        ? clippingStatus.readiness
+        : {};
+    if (readiness.transcript_ready === true) {
+        ready.add("transcription");
+    }
+    if (asset.aiDescription && asset.aiDescription.trim().length > 0) {
+        ready.add("description");
+    }
+    if (readiness.suggestions_ready === true) {
+        ready.add("shorts");
+    }
+    return [...ready];
+}
+function mediaWaitSatisfied({ readyFor, waitFor, }) {
+    if (waitFor === "all") {
+        return (readyFor.includes("processing") &&
+            readyFor.includes("transcription") &&
+            readyFor.includes("description") &&
+            readyFor.includes("shorts"));
+    }
+    return readyFor.includes(waitFor);
+}
+function parseShortContentProfile({ value, }) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "auto" ||
+        value === "podcast" ||
+        value === "tutorial" ||
+        value === "generic") {
+        return value;
+    }
+    throw new Error("--content-profile must be auto, podcast, tutorial, or generic.");
+}
+function summarizeMistakePlan({ plan, }) {
+    const record = isRecord(plan) ? plan : {};
+    const segments = Array.isArray(record.segments)
+        ? record.segments
+        : Array.isArray(record.analyzedSegments)
+            ? record.analyzedSegments
+            : [];
+    const verdictCounts = {};
+    const topSegments = segments.slice(0, 20).map((segment) => {
+        const item = isRecord(segment) ? segment : {};
+        const verdict = typeof item.verdict === "string" ? item.verdict : "unknown";
+        verdictCounts[verdict] = (verdictCounts[verdict] ?? 0) + 1;
+        return {
+            label: item.label,
+            verdict,
+            confidence: item.confidence,
+            trim_start_seconds: item.trimStartSeconds,
+            trim_end_seconds: item.trimEndSeconds,
+            duration_seconds: item.durationSeconds,
+            reason: item.reason,
+            transcript_preview: item.transcriptPreview,
+        };
+    });
+    return {
+        timeline_item_id: record.timelineItemId,
+        media_asset_id: record.mediaAssetId,
+        summary: record.summary,
+        verdict_counts: verdictCounts,
+        segment_count: segments.length,
+        top_segments: topSegments,
+        truncated: segments.length > topSegments.length,
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function buildAgentContext({ commandFilter, surfaceName = "agent-context", }) {
+    const commands = commandFilter
+        ? COMMAND_SPECS.filter((spec) => commandsEqual(spec.command, splitCommandFilter({ value: commandFilter })))
+        : COMMAND_SPECS;
+    if (commandFilter && commands.length === 0) {
+        throw new CliUsageError({
+            code: "unknown_command",
+            message: `Unknown command for ${surfaceName}: ${commandFilter}`,
+            suggestions: suggestCommands({
+                command: splitCommandFilter({ value: commandFilter }),
+            }).map((spec) => commandLabel({ command: spec.command })),
+        });
+    }
+    return {
+        schema_version: "1",
+        cli: {
+            name: "blitzreels",
+            version: CLI_VERSION,
+            default_base_url: DEFAULT_BASE_URL,
+        },
+        commands: commands.map((spec) => ({
+            command: commandLabel({ command: spec.command }),
+            description: spec.description,
+            usage: spec.usage,
+            mutates: spec.mutates,
+            destructive: spec.destructive,
+            requires_auth: spec.requiresAuth,
+            flags: flagsForCommand({ spec }),
+            examples: spec.examples,
+            errors: buildCommandErrors({ spec }),
+        })),
+    };
+}
+function buildAgentPrime({ commandFilter, }) {
+    const context = buildAgentContext({
+        commandFilter,
+        surfaceName: "prime",
+    });
+    return {
+        schema_version: "1",
+        cli: context.cli,
+        instructions: [
+            "Use the BlitzReels CLI for BlitzReels video project inspection, editing, captions, media placement, snapshots, and exports.",
+            "Prefer CLI/SDK/API calls over database access. Do not diagnose normal media pipeline issues by reading Postgres first.",
+            "Use --json for any command whose output you will parse.",
+            "Inspect before editing: project inspect, project timeline, media get, captions list/words list, or clips get.",
+            "Use --dry-run on supported mutating commands before risky edits. Destructive commands still require explicit confirmation flags.",
+            "After every write, verify with project timeline, project inspect, project snapshot, project snapshots, media get, or clips get/wait.",
+            ...timelineLayerModelHelp(),
+            "When a CLI command fails, read the structured error, suggestions, and usage. Do not retry random flag names.",
+        ],
+        workflow: [
+            "1. Run blitzreels auth whoami --json if auth state is uncertain.",
+            "2. Orient with blitzreels project inspect --project-id PROJECT_ID --mode full --json or blitzreels project timeline --project-id PROJECT_ID --json.",
+            "3. Select exact project, media, timeline, caption, or clip IDs from read commands.",
+            "4. Apply the narrowest edit command. Use --dry-run first when available.",
+            "5. Verify the resulting timeline, media state, clip state, snapshot, or export.",
+        ],
+        command_schema_command: commandFilter === undefined
+            ? "blitzreels agent-context --json"
+            : `blitzreels agent-context --command ${JSON.stringify(commandFilter)} --json`,
+        command_filter: commandFilter ?? null,
+        commands: context.commands,
+    };
+}
+function timelineLayerModelHelp() {
+    return [
+        "Timeline layer rule: lower layer_index renders above higher layer_index.",
+        "Default visual order: captions 0, text/effects 1, image B-roll 2, main video 3, audio 4, background/fill 5.",
+        "Use layer_index 2 for normal visible image/video B-roll above the main clip; use 1 only when it must sit above other overlays, and avoid 0 unless replacing captions.",
+    ];
+}
+function splitCommandFilter({ value }) {
+    return value
+        .trim()
+        .split(/\s+/)
+        .filter((part) => part.length > 0);
+}
+function buildCommandErrors({ spec, }) {
+    const errors = [
+        { code: "unknown_command", description: "Command is not registered." },
+        { code: "unknown_flag", description: "Flag is not accepted by command." },
+        { code: "cli_error", description: "Input or local execution failed." },
+    ];
+    if (spec.requiresAuth) {
+        errors.push({
+            code: "api_error",
+            description: "BlitzReels API returned a non-2xx response.",
+        });
+    }
+    if (spec.mutates && !spec.dryRunSupported) {
+        errors.push({
+            code: "unsupported_dry_run",
+            description: "--dry-run was used on a command that cannot preview.",
+        });
+    }
+    return errors;
+}
+function buildAgentContextLines({ value }) {
+    return value.commands.map((command) => `${command.command} ${command.mutates ? "write" : "read"}${command.destructive ? " destructive" : ""} - ${command.description}`);
+}
+function buildAgentPrimeLines({ value }) {
+    const commandLines = value.commands.map((command) => `- ${command.command}: ${command.usage}${command.mutates ? " [writes]" : " [reads]"}${command.destructive ? " [destructive]" : ""}`);
+    return [
+        "<EXTREMELY_IMPORTANT>",
+        "# BlitzReels CLI Usage Guide for AI Agents",
+        "",
+        ...value.instructions.map((line) => `- ${line}`),
+        "",
+        "## Recommended Workflow",
+        "",
+        ...value.workflow.map((line) => `- ${line}`),
+        "",
+        "## Machine-Readable Command Contract",
+        "",
+        `Run: \`${value.command_schema_command}\``,
+        "",
+        "## Relevant Commands",
+        "",
+        ...commandLines,
+        "",
+        "</EXTREMELY_IMPORTANT>",
+    ];
+}
+function resolveDisplayEnvironment({ baseUrl, environment, }) {
+    if (environment === "test" &&
+        (baseUrl?.includes("localhost") || baseUrl?.includes("127.0.0.1"))) {
+        return "local";
+    }
+    return environment;
+}
+function buildProjectDashboardUrl({ baseUrl, projectId, }) {
+    const url = new URL(baseUrl ?? DEFAULT_BASE_URL);
+    if (url.pathname.startsWith("/api/")) {
+        url.pathname = `/dashboard/projects/${encodeURIComponent(projectId)}`;
+    }
+    else {
+        url.pathname = `/dashboard/projects/${encodeURIComponent(projectId)}`;
+    }
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+}
+function buildDryRunPreview({ context, }) {
+    const spec = findCommandSpec({ command: context.args.command });
+    if (!spec?.dryRunSupported) {
+        throw new CliUsageError({
+            code: "unsupported_dry_run",
+            message: "--dry-run is not supported for this command.",
+            usage: spec?.usage,
+        });
+    }
+    const [group, action, subaction] = context.args.command;
+    const flags = context.args.flags;
+    const projectId = () => requireStringFlag({ flags, name: "project-id" });
+    const assetId = () => requireStringFlag({ flags, name: "asset-id" });
+    const folderId = () => requireStringFlag({ flags, name: "folder-id" });
+    const timelineItemId = () => requireStringFlag({ flags, name: "timeline-item-id" });
+    if (group === "workspace" &&
+        action === "settings" &&
+        subaction === "update") {
+        return dryRunRequest({
+            spec,
+            method: "PATCH",
+            path: "/workspace/settings",
+            body: {
+                name: getStringFlag({ flags, name: "name" }),
+                description: parseNullableStringFlag({ flags, name: "description" }),
+                protected_words: parseCsvFlag({ flags, name: "protected-words" }),
+                icon_storage_key: parseNullableStringFlag({
+                    flags,
+                    name: "icon-storage-key",
+                }),
+                defaults: toApiWorkspaceDefaults({ flags }),
+            },
+        });
+    }
+    if (group === "projects" && action === "create") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: "/projects",
+            body: {
+                name: requireStringFlag({ flags, name: "name" }),
+                description: getStringFlag({ flags, name: "description" }),
+                aspect_ratio: parseAspectRatio({
+                    value: getStringFlag({ flags, name: "aspect-ratio" }),
+                }),
+                project_type: parseProjectType({
+                    value: getStringFlag({ flags, name: "project-type" }),
+                }),
+                carousel_settings: parseJsonObjectFlag({
+                    flags,
+                    name: "carousel-settings-json",
+                }),
+            },
+        });
+    }
+    if (group === "projects" && (action === "rename" || action === "update")) {
+        return dryRunRequest({
+            spec,
+            method: "PATCH",
+            path: `/projects/${encodeURIComponent(projectId())}`,
+            body: {
+                name: action === "rename"
+                    ? requireStringFlag({ flags, name: "name" })
+                    : getStringFlag({ flags, name: "name" }),
+                description: action === "rename"
+                    ? undefined
+                    : parseNullableStringFlag({ flags, name: "description" }),
+            },
+        });
+    }
+    if (group === "projects" && action === "delete") {
+        requireDeleteConfirmation({
+            confirmed: getBooleanFlag({ flags, name: "confirm-delete" }),
+        });
+        return dryRunRequest({
+            spec,
+            method: "DELETE",
+            path: `/projects/${encodeURIComponent(projectId())}`,
+            body: undefined,
+        });
+    }
+    if (group === "media" && action === "delete") {
+        requireDeleteConfirmation({
+            confirmed: getBooleanFlag({ flags, name: "confirm-delete" }),
+        });
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/workspace/media/assets/${encodeURIComponent(assetId())}/delete`,
+            body: {},
+        });
+    }
+    if (group === "media" && (action === "update" || action === "rename")) {
+        return dryRunRequest({
+            spec,
+            method: "PATCH",
+            path: `/workspace/media/assets/${encodeURIComponent(assetId())}`,
+            body: {
+                name: action === "rename"
+                    ? requireStringFlag({ flags, name: "name" })
+                    : getStringFlag({ flags, name: "name" }),
+                description: action === "rename"
+                    ? undefined
+                    : parseNullableStringFlag({ flags, name: "description" }),
+                folder_id: action === "rename"
+                    ? undefined
+                    : parseFolderIdFlag({ flags, name: "folder-id" }),
+                allow_using_as_broll: action === "rename"
+                    ? undefined
+                    : getOptionalBooleanFlag({ flags, name: "allow-broll" }),
+            },
+        });
+    }
+    if (group === "media" && action === "move") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: "/workspace/media/assets/move",
+            body: {
+                asset_ids: parseAssetIds({ flags }),
+                target_folder_id: requireFolderIdFlag({
+                    flags,
+                    name: "target-folder-id",
+                }),
+            },
+        });
+    }
+    if ((group === "media" && action === "attach") ||
+        (group === "broll" && action === "add")) {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/projects/${encodeURIComponent(projectId())}/timeline/media`,
+            body: {
+                items: [
+                    {
+                        asset_id: assetId(),
+                        start_seconds: getStringFlag({ flags, name: "at" }) === undefined
+                            ? 0
+                            : parseTimecode({
+                                value: requireStringFlag({ flags, name: "at" }),
+                            }),
+                        duration_seconds: getNumberFlag({ flags, name: "duration" }) ?? null,
+                        position_preset: toApiMediaPositionPreset({
+                            value: parseMediaPositionPreset({
+                                value: getStringFlag({ flags, name: "position-preset" }),
+                            }),
+                        }),
+                        position_x: getNumberFlag({ flags, name: "position-x" }),
+                        position_y: getNumberFlag({ flags, name: "position-y" }),
+                        width_px: getNumberFlag({ flags, name: "width-px" }),
+                        height_px: getNumberFlag({ flags, name: "height-px" }),
+                        scale: getNumberFlag({ flags, name: "scale" }),
+                        opacity: getNumberFlag({ flags, name: "opacity" }),
+                        animation_preset: toApiMediaAnimationPreset({
+                            value: parseMediaAnimationPreset({
+                                value: getStringFlag({ flags, name: "animation-preset" }),
+                            }),
+                        }),
+                        layer_index: getNumberFlag({ flags, name: "layer-index" }),
+                    },
+                ],
+                allow_duplicate: getOptionalBooleanFlag({
+                    flags,
+                    name: "allow-duplicate",
+                }),
+            },
+        });
+    }
+    if (group === "media" && action === "overlay" && subaction === "update") {
+        return dryRunRequest({
+            spec,
+            method: "PATCH",
+            path: `/projects/${encodeURIComponent(projectId())}/timeline/media/${encodeURIComponent(requireStringFlag({ flags, name: "timeline-item-id" }))}`,
+            body: {
+                position_preset: toApiMediaPositionPreset({
+                    value: parseMediaPositionPreset({
+                        value: getStringFlag({ flags, name: "position-preset" }),
+                    }),
+                }),
+                position_x: getNumberFlag({ flags, name: "position-x" }),
+                position_y: getNumberFlag({ flags, name: "position-y" }),
+                width_px: getNumberFlag({ flags, name: "width-px" }),
+                height_px: getNumberFlag({ flags, name: "height-px" }),
+                scale: getNumberFlag({ flags, name: "scale" }),
+                animation_preset: toApiMediaAnimationPreset({
+                    value: parseMediaAnimationPreset({
+                        value: getStringFlag({ flags, name: "animation-preset" }),
+                    }),
+                }),
+                remove_animations: getOptionalBooleanFlag({
+                    flags,
+                    name: "remove-animations",
+                }),
+                blurred_background: getOptionalBooleanFlag({
+                    flags,
+                    name: "blurred-background",
+                }),
+            },
+        });
+    }
+    if (group === "clips" && action === "create") {
+        const options = toCreateClipOptions({ flags });
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: "/clips",
+            body: {
+                project_name: options.projectName,
+                source: {
+                    source_type: options.source.sourceType,
+                    asset_id: options.source.assetId,
+                    youtube_url: options.source.youtubeUrl,
+                },
+                selection: {
+                    selection_mode: options.selection.mode,
+                    suggestion_id: options.selection.suggestionId,
+                    start_seconds: options.selection.startSeconds,
+                    end_seconds: options.selection.endSeconds,
+                },
+                target: {
+                    aspect_ratio: options.target.aspectRatio,
+                    min_duration_seconds: options.target.minDurationSeconds,
+                    max_duration_seconds: options.target.maxDurationSeconds,
+                },
+                layout: {
+                    layout_mode: options.layout.mode,
+                    content_type_hint: options.layout.contentTypeHint,
+                },
+                captions: {
+                    enabled: options.captions.enabled,
+                    style_id: options.captions.styleId,
+                },
+                qa: {
+                    qa_mode: options.qa.mode,
+                },
+                export: {
+                    auto_export: options.export.autoExport,
+                },
+            },
+        });
+    }
+    if (group === "clips" && action === "reselect") {
+        const target = buildClipTarget({ flags, requireMaxDuration: false });
+        const selection = buildClipSelection({ flags });
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/clips/${encodeURIComponent(requireStringFlag({ flags, name: "clip-id" }))}/reselect`,
+            body: {
+                selection: {
+                    selection_mode: selection.mode,
+                    suggestion_id: selection.suggestionId,
+                    start_seconds: selection.startSeconds,
+                    end_seconds: selection.endSeconds,
+                },
+                target: target === null
+                    ? null
+                    : {
+                        min_duration_seconds: target.minDurationSeconds,
+                        max_duration_seconds: target.maxDurationSeconds,
+                    },
+            },
+        });
+    }
+    if (group === "clips" && action === "repair") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/clips/${encodeURIComponent(requireStringFlag({ flags, name: "clip-id" }))}/repair`,
+            body: {
+                repair_mode: parseClipRepairMode({
+                    value: getStringFlag({ flags, name: "repair-mode" }),
+                }),
+            },
+        });
+    }
+    if (group === "clips" && action === "export") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/clips/${encodeURIComponent(requireStringFlag({ flags, name: "clip-id" }))}/export`,
+            body: {
+                resolution: parseClipExportResolution({
+                    value: getStringFlag({ flags, name: "resolution" }),
+                }),
+                format: parseClipExportFormat({
+                    value: getStringFlag({ flags, name: "format" }),
+                }),
+                allow_blocking_qa_bypass: getOptionalBooleanFlag({
+                    flags,
+                    name: "allow-blocking-qa-bypass",
+                }) ?? false,
+            },
+        });
+    }
+    if (group === "media" && action === "folders" && subaction === "create") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: "/workspace/media/folders",
+            body: {
+                name: requireStringFlag({ flags, name: "name" }),
+                parent_folder_id: parseFolderIdFlag({
+                    flags,
+                    name: "parent-folder-id",
+                }),
+                description: parseNullableStringFlag({ flags, name: "description" }),
+                icon_type: getStringFlag({ flags, name: "icon-type" }),
+            },
+        });
+    }
+    if (group === "media" &&
+        action === "folders" &&
+        (subaction === "rename" || subaction === "update")) {
+        return dryRunRequest({
+            spec,
+            method: "PATCH",
+            path: `/workspace/media/folders/${encodeURIComponent(folderId())}`,
+            body: {
+                name: subaction === "rename"
+                    ? requireStringFlag({ flags, name: "name" })
+                    : getStringFlag({ flags, name: "name" }),
+                parent_folder_id: subaction === "rename"
+                    ? undefined
+                    : parseFolderIdFlag({ flags, name: "parent-folder-id" }),
+                description: subaction === "rename"
+                    ? undefined
+                    : parseNullableStringFlag({ flags, name: "description" }),
+                icon_type: subaction === "rename"
+                    ? undefined
+                    : getStringFlag({ flags, name: "icon-type" }),
+            },
+        });
+    }
+    if (group === "media" && action === "folders" && subaction === "delete") {
+        requireDeleteConfirmation({
+            confirmed: getBooleanFlag({ flags, name: "confirm-delete" }),
+        });
+        return dryRunRequest({
+            spec,
+            method: "DELETE",
+            path: `/workspace/media/folders/${encodeURIComponent(folderId())}`,
+            query: { cascade: getOptionalBooleanFlag({ flags, name: "cascade" }) },
+            body: undefined,
+        });
+    }
+    if (group === "text" && action === "add") {
+        const text = requireStringFlag({ flags, name: "text" });
+        const durationSeconds = getNumberFlag({ flags, name: "duration" }) ?? 4;
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/projects/${encodeURIComponent(projectId())}/content-items`,
+            body: {
+                kind: "overlay",
+                text,
+                name: getStringFlag({ flags, name: "name" }),
+                spec: parseJsonObjectFlag({ flags, name: "spec-json" }) ??
+                    (hasTextStyleFlags({ flags })
+                        ? buildTextOverlaySpec({
+                            text,
+                            name: getStringFlag({ flags, name: "name" }),
+                            durationSeconds,
+                            flags,
+                        })
+                        : undefined),
+                start_seconds: parseTimecode({
+                    value: getStringFlag({ flags, name: "at" }) ?? "0",
+                }),
+                duration_seconds: durationSeconds,
+                layer_index: getNumberFlag({ flags, name: "layer-index" }),
+            },
+        });
+    }
+    if (group === "text" && action === "update") {
+        return dryRunRequest({
+            spec,
+            method: "PATCH",
+            path: `/projects/${encodeURIComponent(projectId())}/content-items/${encodeURIComponent(requireStringFlag({ flags, name: "content-item-id" }))}`,
+            body: {
+                name: getStringFlag({ flags, name: "name" }),
+                text: getStringFlag({ flags, name: "text" }),
+                spec: parseJsonObjectFlag({ flags, name: "spec-json" }),
+                duration_seconds: getNumberFlag({ flags, name: "duration" }),
+            },
+            notes: hasTextStyleFlags({ flags })
+                ? [
+                    "Style flags require reading the existing content item before building the final spec during real execution.",
+                ]
+                : undefined,
+        });
+    }
+    if (group === "text" && action === "remove") {
+        return dryRunRequest({
+            spec,
+            method: "DELETE",
+            path: `/projects/${encodeURIComponent(projectId())}/content-items/${encodeURIComponent(requireStringFlag({ flags, name: "content-item-id" }))}`,
+            body: undefined,
+        });
+    }
+    if (group === "timeline" && action === "transform") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/projects/${encodeURIComponent(projectId())}/timeline/edits`,
+            body: {
+                action: "transform",
+                timeline_item_id: timelineItemId(),
+                position_x: getNumberFlag({ flags, name: "position-x" }),
+                position_y: getNumberFlag({ flags, name: "position-y" }),
+                width_px: parseNullableNumberFlag({ flags, name: "width-px" }),
+                height_px: parseNullableNumberFlag({ flags, name: "height-px" }),
+                keep_aspect_ratio: getOptionalBooleanFlag({
+                    flags,
+                    name: "keep-aspect-ratio",
+                }),
+            },
+        });
+    }
+    if (group === "timeline" && action === "move") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/projects/${encodeURIComponent(projectId())}/timeline/edits`,
+            body: {
+                action: "move",
+                timeline_item_id: timelineItemId(),
+                new_start_seconds: parseTimecode({
+                    value: requireStringFlag({ flags, name: "at" }),
+                }),
+                new_layer_index: getNumberFlag({ flags, name: "layer-index" }),
+            },
+        });
+    }
+    if (group === "timeline" && action === "delete") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/projects/${encodeURIComponent(projectId())}/timeline/edits`,
+            body: {
+                action: "delete",
+                timeline_item_ids: parseTimelineItemIds({ flags }),
+                auto_pack: getOptionalBooleanFlag({ flags, name: "auto-pack" }),
+            },
+        });
+    }
+    if (group === "audio" && action === "add") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/projects/${encodeURIComponent(projectId())}/timeline/audio`,
+            body: {
+                items: [
+                    {
+                        asset_id: assetId(),
+                        start_seconds: parseTimecode({
+                            value: getStringFlag({ flags, name: "at" }) ?? "0",
+                        }),
+                        duration_seconds: getNumberFlag({ flags, name: "duration" }),
+                        volume: getNumberFlag({ flags, name: "volume" }),
+                        fade_in_seconds: getNumberFlag({ flags, name: "fade-in" }),
+                        fade_out_seconds: getNumberFlag({ flags, name: "fade-out" }),
+                        loop: getOptionalBooleanFlag({ flags, name: "loop" }),
+                    },
+                ],
+            },
+        });
+    }
+    if (group === "audio" && action === "import") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: "/audio-library/import",
+            body: {
+                provider: parseAudioLibraryProvider({
+                    value: requireStringFlag({ flags, name: "provider" }),
+                }),
+                external_id: requireStringFlag({ flags, name: "external-id" }),
+                folder_id: parseFolderIdFlag({ flags, name: "folder-id" }),
+                project_id: getStringFlag({ flags, name: "project-id" }),
+                start_seconds: parseTimecode({
+                    value: getStringFlag({ flags, name: "at" }) ?? "0",
+                }),
+                duration_seconds: parseNullableNumberFlag({ flags, name: "duration" }),
+                volume: getNumberFlag({ flags, name: "volume" }),
+                fade_in_seconds: getNumberFlag({ flags, name: "fade-in" }),
+                fade_out_seconds: getNumberFlag({ flags, name: "fade-out" }),
+                loop: getOptionalBooleanFlag({ flags, name: "loop" }),
+                audio_type: parseAudioLibraryType({
+                    value: getStringFlag({ flags, name: "audio-type" }),
+                }),
+            },
+        });
+    }
+    if (group === "audio" && action === "update") {
+        return dryRunRequest({
+            spec,
+            method: "PATCH",
+            path: `/projects/${encodeURIComponent(projectId())}/timeline/audio/${encodeURIComponent(requireStringFlag({ flags, name: "timeline-item-id" }))}`,
+            body: {
+                duration_seconds: getNumberFlag({ flags, name: "duration" }),
+                volume: getNumberFlag({ flags, name: "volume" }),
+                fade_in_seconds: getNumberFlag({ flags, name: "fade-in" }),
+                fade_out_seconds: getNumberFlag({ flags, name: "fade-out" }),
+            },
+        });
+    }
+    if (group === "library" && action === "import") {
+        const libraryAssetId = requireStringFlag({
+            flags,
+            name: "library-asset-id",
+        });
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/library/broll/${encodeURIComponent(libraryAssetId)}/import`,
+            body: {
+                folder_id: parseFolderIdFlag({ flags, name: "folder-id" }),
+            },
+        });
+    }
+    if (group === "captions" && action === "words") {
+        return buildCaptionWordsDryRun({ spec, flags, subaction });
+    }
+    if (group === "captions" &&
+        (action === "list-words" ||
+            action === "style-words" ||
+            action === "emphasize")) {
+        const aliasSubaction = action === "list-words"
+            ? "list"
+            : action === "style-words"
+                ? "style"
+                : "emphasis";
+        return buildCaptionWordsDryRun({ spec, flags, subaction: aliasSubaction });
+    }
+    if (group === "captions" &&
+        (action === "delete" || action === "hide" || action === "show")) {
+        return buildCaptionTrackDryRun({ spec, flags, action });
+    }
+    if (group === "captions" && action === "theme" && subaction === "set") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/projects/${encodeURIComponent(projectId())}/caption-theme`,
+            body: {
+                theme_id: requireStringFlag({ flags, name: "theme-id" }),
+            },
+        });
+    }
+    if (group === "captions" && action === "theme" && subaction === "update") {
+        return dryRunRequest({
+            spec,
+            method: "PATCH",
+            path: `/caption-themes/${encodeURIComponent(requireStringFlag({ flags, name: "theme-id" }))}`,
+            body: {
+                name: getStringFlag({ flags, name: "name" }),
+                description: getStringFlag({ flags, name: "description" }),
+                settings: buildCaptionThemeSettingsPatch({ flags }),
+            },
+        });
+    }
+    if (group === "captions" &&
+        action === "theme" &&
+        subaction === "set-default") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/caption-themes/${encodeURIComponent(requireStringFlag({ flags, name: "theme-id" }))}/set-default`,
+            body: {},
+        });
+    }
+    if (group === "exports" && action === "start") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/projects/${encodeURIComponent(projectId())}/export`,
+            body: {
+                resolution: getStringFlag({ flags, name: "resolution" }),
+                format: getStringFlag({ flags, name: "format" }),
+            },
+        });
+    }
+    throw new CliUsageError({
+        code: "unsupported_dry_run",
+        message: `--dry-run is not implemented for ${commandLabel({ command: spec.command })}.`,
+        usage: spec.usage,
     });
 }
-async function loginWithBrowser({ context, }) {
-    const appUrl = resolveAppUrl({ baseUrl: context.config.baseUrl });
-    const deviceUrl = `${appUrl}/api/cli/auth/device`;
-    const startResponse = await fetch(deviceUrl, {
-        method: "POST",
-        headers: { Accept: "application/json" },
-    });
-    const login = parseDeviceLoginResponse({
-        value: await readJsonResponse({
-            response: startResponse,
-            url: deviceUrl,
-            action: "start CLI login",
-        }),
-    });
-    const shouldOpenBrowser = !getBooleanFlag({
-        flags: context.args.flags,
-        name: "no-browser",
-    });
-    if (shouldOpenBrowser) {
-        openBrowser({ url: login.verification_uri_complete });
+function buildCaptionWordsDryRun({ spec, flags, subaction, }) {
+    const projectId = requireStringFlag({ flags, name: "project-id" });
+    const basePath = `/projects/${encodeURIComponent(projectId)}/captions/words`;
+    if (subaction === "text") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `${basePath}/text`,
+            body: {
+                word_id: requireStringFlag({ flags, name: "word-id" }),
+                new_text: getStringFlag({ flags, name: "new-text" }) ??
+                    requireStringFlag({ flags, name: "text" }),
+            },
+        });
     }
-    const loginInstructions = [
-        `First copy your one-time code: ${login.user_code}`,
-        `Then open: ${login.verification_uri_complete}`,
-        "Waiting for browser approval...",
-    ];
-    if (context.json) {
-        console.error(loginInstructions.join("\n"));
+    if (subaction === "batch-text") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `${basePath}/batch-text`,
+            body: {
+                updates: parseWordTextUpdatesFlag({ flags, name: "updates-json" }),
+            },
+        });
     }
-    else {
-        printResult({
-            json: context.json,
-            value: {
-                user_code: login.user_code,
-                verification_uri: login.verification_uri_complete,
-                expires_in: login.expires_in,
+    if (subaction === "style") {
+        const styleJson = parseNullableJsonObjectFlag({
+            flags,
+            name: "style-json",
+        });
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `${basePath}/style`,
+            body: {
+                ...buildCaptionWordSelectorBody({ flags }),
+                style: styleJson === undefined
+                    ? buildCaptionWordStyleFromFlags({ flags })
+                    : styleJson,
+                clear_existing: getOptionalBooleanFlag({
+                    flags,
+                    name: "clear-existing",
+                }),
             },
-            human: loginInstructions,
         });
     }
-    const startedAt = Date.now();
-    const timeoutMs = Math.min(login.expires_in * 1000, getNumberFlag({ flags: context.args.flags, name: "timeout-ms" }) ??
-        login.expires_in * 1000);
-    const intervalMs = Math.max(1000, login.interval * 1000);
-    while (Date.now() - startedAt <= timeoutMs) {
-        await sleep({ ms: intervalMs });
-        const tokenUrl = `${appUrl}/api/cli/auth/token`;
-        const pollResponse = await fetch(tokenUrl, {
+    if (subaction === "emphasis") {
+        return dryRunRequest({
+            spec,
             method: "POST",
-            headers: {
-                Accept: "application/json",
-                "Content-Type": "application/json",
+            path: `${basePath}/emphasis`,
+            body: {
+                ...buildCaptionWordSelectorBody({ flags }),
+                emphasis: getOptionalBooleanFlag({ flags, name: "emphasis" }) ?? true,
             },
-            body: JSON.stringify({ device_code: login.device_code }),
         });
-        const result = parseDeviceTokenResponse({
-            value: await readJsonResponse({
-                response: pollResponse,
-                url: tokenUrl,
-                action: "poll CLI login",
+    }
+    if (subaction === "delete") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `${basePath}/delete`,
+            body: { word_ids: parseWordIds({ flags }) },
+        });
+    }
+    if (subaction === "merge") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `${basePath}/merge`,
+            body: {
+                word_ids: parseWordIds({ flags }),
+                text: getStringFlag({ flags, name: "text" }),
+            },
+        });
+    }
+    if (subaction === "split") {
+        return dryRunRequest({
+            spec,
+            method: "POST",
+            path: `${basePath}/split`,
+            body: {
+                word_id: requireStringFlag({ flags, name: "word-id" }),
+                words: parseCsvRequiredFlag({ flags, name: "words" }),
+            },
+        });
+    }
+    throw new CliUsageError({
+        code: "unsupported_dry_run",
+        message: `--dry-run is not implemented for captions words ${subaction ?? ""}.`,
+        usage: spec.usage,
+    });
+}
+function buildCaptionTrackDryRun({ spec, flags, action, }) {
+    const selector = buildCaptionTrackSelectorBody({ flags });
+    return dryRunRequest({
+        spec,
+        method: "POST",
+        path: `/projects/${encodeURIComponent(requireStringFlag({ flags, name: "project-id" }))}/captions/${action}`,
+        body: selector,
+    });
+}
+function buildCaptionWordSelectorBody({ flags, }) {
+    return {
+        word_ids: parseCsvFlag({ flags, name: "word-ids" }) ??
+            parseCsvFlag({ flags, name: "word-id" }),
+        match_text: getStringFlag({ flags, name: "match-text" }),
+        match_pattern: parseCaptionMatchPattern({
+            value: getStringFlag({ flags, name: "match-pattern" }),
+        }),
+        timeline_item_id: getStringFlag({ flags, name: "timeline-item-id" }),
+        all: getOptionalBooleanFlag({ flags, name: "all" }),
+        from_seconds: getStringFlag({ flags, name: "from" }) === undefined
+            ? undefined
+            : parseTimecode({
+                value: requireStringFlag({ flags, name: "from" }),
+            }),
+        to_seconds: getStringFlag({ flags, name: "to" }) === undefined
+            ? undefined
+            : parseTimecode({
+                value: requireStringFlag({ flags, name: "to" }),
             }),
+    };
+}
+function buildCaptionTrackSelectorBody({ flags, }) {
+    return {
+        all: getOptionalBooleanFlag({ flags, name: "all" }),
+        caption_id: getStringFlag({ flags, name: "caption-id" }),
+        timeline_item_id: getStringFlag({ flags, name: "timeline-item-id" }),
+        from_seconds: getStringFlag({ flags, name: "from" }) === undefined
+            ? undefined
+            : parseTimecode({
+                value: requireStringFlag({ flags, name: "from" }),
+            }),
+        to_seconds: getStringFlag({ flags, name: "to" }) === undefined
+            ? undefined
+            : parseTimecode({
+                value: requireStringFlag({ flags, name: "to" }),
+            }),
+    };
+}
+function buildCaptionTrackSelector({ flags }) {
+    const body = buildCaptionTrackSelectorBody({ flags });
+    return {
+        projectId: requireStringFlag({ flags, name: "project-id" }),
+        all: body.all,
+        captionId: body.caption_id,
+        timelineItemId: body.timeline_item_id,
+        fromSeconds: body.from_seconds,
+        toSeconds: body.to_seconds,
+    };
+}
+function dryRunRequest({ spec, method, path, query, body, followUpRequests, notes, }) {
+    return buildDryRunRequest({
+        spec,
+        method,
+        path,
+        query,
+        body,
+        followUpRequests,
+        notes,
+    });
+}
+function toApiWorkspaceDefaults({ flags, }) {
+    const defaults = buildWorkspaceDefaults({ flags });
+    if (defaults === undefined) {
+        return undefined;
+    }
+    return {
+        aspect_ratio: defaults.aspectRatio,
+        orientation: defaults.orientation,
+        resolution: defaults.resolution,
+        frame_rate: defaults.frameRate,
+        auto_manage_broll: defaults.autoManageBroll,
+        caption_theme_id: defaults.captionThemeId,
+    };
+}
+function applyFieldSelection({ value, fields, }) {
+    if (Array.isArray(value)) {
+        return value.map((item) => applyFieldSelection({ value: item, fields }));
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    const record = value;
+    const arrayEntries = Object.entries(record).filter(([, item]) => Array.isArray(item));
+    if (arrayEntries.length === 1) {
+        const [key, items] = arrayEntries[0];
+        return {
+            ...record,
+            [key]: items.map((item) => applyFieldSelection({ value: item, fields })),
+        };
+    }
+    return Object.fromEntries(fields
+        .filter((field) => field in record)
+        .map((field) => [field, record[field]]));
+}
+function validateSafeInputs({ parsed }) {
+    for (const [name, value] of Object.entries(parsed.flags)) {
+        if (typeof value !== "string") {
+            continue;
+        }
+        rejectControlChars({ name, value });
+        if (isIdLikeFlag({ name })) {
+            rejectUnsafeId({ name, value });
+        }
+        if (name === "url") {
+            rejectUnsafeUrl({ name, value });
+        }
+        if (name === "output") {
+            rejectUnsafeOutputPath({ value });
+        }
+    }
+}
+function rejectControlChars({ name, value, }) {
+    if (Array.from(value).some((character) => {
+        const code = character.charCodeAt(0);
+        return code < 32 || code === 127;
+    })) {
+        throw new CliUsageError({
+            code: "unsafe_input",
+            message: `--${name} contains control characters.`,
         });
-        if (result.status === "approved" && result.api_key) {
-            await persistLoggedInApiKey({
-                apiKey: result.api_key,
-                baseUrl: context.config.baseUrl,
-            });
-            printResult({
-                json: context.json,
-                value: { success: true, key_prefix: result.key_prefix ?? "" },
-                human: [`Logged in. API key prefix: ${result.key_prefix ?? "saved"}`],
-            });
+    }
+}
+function isIdLikeFlag({ name }) {
+    return name === "id" || name.endsWith("-id") || name.endsWith("-ids");
+}
+function rejectUnsafeId({ name, value, }) {
+    if (/[?#%]/.test(value)) {
+        throw new CliUsageError({
+            code: "unsafe_input",
+            message: `--${name} must be an ID, not a URL or encoded path.`,
+        });
+    }
+}
+function rejectUnsafeUrl({ name, value, }) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new CliUsageError({
+            code: "unsafe_input",
+            message: `--${name} must be a valid URL.`,
+        });
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new CliUsageError({
+            code: "unsafe_input",
+            message: `--${name} must use http or https.`,
+        });
+    }
+    if (url.username || url.password) {
+        throw new CliUsageError({
+            code: "unsafe_input",
+            message: `--${name} must not include embedded credentials.`,
+        });
+    }
+}
+function rejectUnsafeOutputPath({ value }) {
+    const outputPath = resolve(value);
+    const sensitiveDirs = [join(homedir(), ".ssh"), join(homedir(), ".gnupg")];
+    if (sensitiveDirs.some((dir) => outputPath.startsWith(`${dir}/`) || outputPath === dir)) {
+        throw new CliUsageError({
+            code: "unsafe_input",
+            message: "--output cannot write into sensitive home directories.",
+        });
+    }
+}
+async function maybePrintUpdateNotice({ parsed, baseUrl, json, }) {
+    if (!shouldRunPassiveUpdateCheck({ parsed, json })) {
+        return;
+    }
+    try {
+        const update = await getUpdateStatus({ baseUrl, cachePolicy: "cache" });
+        if (!update.updateAvailable) {
             return;
         }
-        if (result.status === "expired" ||
-            result.status === "denied" ||
-            result.status === "invalid" ||
-            result.status === "consumed") {
-            throw new Error(`Login failed: ${result.status}.`);
-        }
+        console.error(buildUpdateNotice({ update }).join("\n"));
+    }
+    catch {
+        // Update checks must never affect the requested CLI command.
+    }
+}
+function shouldRunPassiveUpdateCheck({ parsed, json, }) {
+    if (json) {
+        return false;
+    }
+    if (process.env.BLITZREELS_NO_UPDATE_NOTIFIER === "1") {
+        return false;
+    }
+    if (process.env.CI === "true") {
+        return false;
+    }
+    if (!process.stderr.isTTY &&
+        process.env.BLITZREELS_FORCE_UPDATE_NOTIFIER !== "1") {
+        return false;
+    }
+    if (parsed.command.length === 0 ||
+        parsed.command[0] === "version" ||
+        parsed.command[0] === "doctor" ||
+        parsed.command[0] === "agent-context" ||
+        parsed.command[0] === "schema" ||
+        parsed.command[0] === "prime" ||
+        parsed.command[0] === "llms" ||
+        getBooleanFlag({ flags: parsed.flags, name: "help" })) {
+        return false;
+    }
+    return true;
+}
+async function getUpdateStatus({ baseUrl, cachePolicy, }) {
+    const cached = await readUpdateCache();
+    const now = Date.now();
+    if (cachePolicy === "cache" &&
+        cached &&
+        now - cached.fetchedAt < UPDATE_CHECK_TTL_MS) {
+        return buildUpdateStatus({ manifest: cached.manifest, source: "cache" });
+    }
+    const manifest = await fetchUpdateManifest({ baseUrl }).catch(() => undefined);
+    if (manifest) {
+        await writeUpdateCache({ manifest });
+        return buildUpdateStatus({ manifest, source: "network" });
+    }
+    if (cached) {
+        return buildUpdateStatus({ manifest: cached.manifest, source: "cache" });
+    }
+    return buildUpdateStatus({
+        manifest: buildFallbackUpdateManifest(),
+        source: "fallback",
+    });
+}
+function buildUpdateStatus({ manifest, source, }) {
+    return {
+        current: CLI_VERSION,
+        manifest,
+        updateAvailable: isVersionLessThan({
+            left: CLI_VERSION,
+            right: manifest.latest,
+        }),
+        source,
+    };
+}
+async function fetchUpdateManifest({ baseUrl, }) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, UPDATE_CHECK_TIMEOUT_MS);
+    try {
+        const response = await fetch(resolveUpdateManifestUrl({ baseUrl }), {
+            headers: {
+                Accept: "application/json",
+                "User-Agent": `blitzreels-cli/${CLI_VERSION}`,
+            },
+            signal: controller.signal,
+        });
+        const value = await readJsonResponse({
+            response,
+            url: resolveUpdateManifestUrl({ baseUrl }),
+            action: "check CLI updates",
+        });
+        return parseUpdateManifest({ value });
+    }
+    finally {
+        clearTimeout(timeout);
     }
-    throw new Error("Timed out waiting for browser approval.");
 }
-async function uploadMediaFile({ context }) {
-    const filePath = resolve(requireStringFlag({ flags: context.args.flags, name: "file" }));
-    const fileStats = await stat(filePath);
-    if (!fileStats.isFile()) {
-        throw new Error(`Not a file: ${filePath}`);
+function resolveUpdateManifestUrl({ baseUrl, }) {
+    if (process.env.BLITZREELS_UPDATE_MANIFEST_URL) {
+        return process.env.BLITZREELS_UPDATE_MANIFEST_URL;
     }
-    const fileName = getStringFlag({ flags: context.args.flags, name: "name" }) ??
-        basename(filePath);
-    const contentType = getStringFlag({ flags: context.args.flags, name: "content-type" }) ??
-        inferContentType({ filePath });
-    const init = await context.client.media.initUpload({
-        fileName,
-        contentType,
-    });
-    const bytes = await readFile(filePath);
-    const uploadResponse = await fetch(init.upload_url, {
-        method: "PUT",
-        headers: { "Content-Type": contentType },
-        body: new Blob([new Uint8Array(bytes)], { type: contentType }),
-    });
-    if (!uploadResponse.ok) {
-        throw new Error(`Upload failed with ${uploadResponse.status}: ${await uploadResponse.text()}`);
+    return `${resolveAppUrl({ baseUrl })}/api/cli/releases`;
+}
+async function readUpdateCache() {
+    try {
+        const raw = await readFile(UPDATE_CACHE_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        return parseUpdateCache({ value: parsed });
     }
-    return context.client.media.finalizeUpload({
-        storageKey: init.storage_key,
-        fileName,
-        contentType,
-        fileSizeBytes: fileStats.size,
-        autoProcessEnabled: getOptionalBooleanFlag({
-            flags: context.args.flags,
-            name: "auto-process",
-        }),
-        autoTranscribe: getOptionalBooleanFlag({
-            flags: context.args.flags,
-            name: "auto-transcribe",
-        }),
-        autoDescribeAfterTranscribe: getOptionalBooleanFlag({
-            flags: context.args.flags,
-            name: "auto-describe",
-        }),
-        autoSuggestShorts: getOptionalBooleanFlag({
-            flags: context.args.flags,
-            name: "auto-suggest-shorts",
-        }),
+    catch {
+        return undefined;
+    }
+}
+async function writeUpdateCache({ manifest, }) {
+    await mkdir(dirname(UPDATE_CACHE_PATH), { recursive: true });
+    await writeFile(UPDATE_CACHE_PATH, JSON.stringify({ fetchedAt: Date.now(), manifest }, null, 2), { mode: 0o600 });
+}
+function parseUpdateCache({ value, }) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const record = value;
+    if (typeof record.fetchedAt !== "number") {
+        return undefined;
+    }
+    return {
+        fetchedAt: record.fetchedAt,
+        manifest: parseUpdateManifest({ value: record.manifest }),
+    };
+}
+function parseUpdateManifest({ value }) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("CLI release manifest returned an invalid response.");
+    }
+    const record = value;
+    const upgrade = record.upgrade;
+    if (!upgrade || typeof upgrade !== "object" || Array.isArray(upgrade)) {
+        throw new Error("CLI release manifest is missing upgrade commands.");
+    }
+    const upgradeRecord = upgrade;
+    const severity = record.severity === "warning" || record.severity === "critical"
+        ? record.severity
+        : "notice";
+    if (typeof record.latest !== "string" ||
+        typeof record.minRecommended !== "string" ||
+        typeof record.minSupported !== "string" ||
+        typeof record.releasedAt !== "string" ||
+        !Array.isArray(record.changes) ||
+        typeof upgradeRecord.npm !== "string" ||
+        typeof upgradeRecord.pnpm !== "string" ||
+        typeof upgradeRecord.npx !== "string" ||
+        typeof record.url !== "string") {
+        throw new Error("CLI release manifest returned an incomplete response.");
+    }
+    return {
+        latest: record.latest,
+        minRecommended: record.minRecommended,
+        minSupported: record.minSupported,
+        severity,
+        releasedAt: record.releasedAt,
+        changes: record.changes.filter((change) => typeof change === "string"),
+        upgrade: {
+            npm: upgradeRecord.npm,
+            pnpm: upgradeRecord.pnpm,
+            npx: upgradeRecord.npx,
+        },
+        url: record.url,
+    };
+}
+function buildFallbackUpdateManifest() {
+    return {
+        latest: CLI_VERSION,
+        minRecommended: CLI_VERSION,
+        minSupported: CLI_VERSION,
+        severity: "notice",
+        releasedAt: "2026-05-08",
+        changes: [],
+        upgrade: {
+            npm: "npm i -g blitzreels@latest",
+            pnpm: "pnpm add -g blitzreels@latest",
+            npx: "npx blitzreels@latest",
+        },
+        url: "https://www.blitzreels.com/changelog",
+    };
+}
+function buildUpdateNotice({ update }) {
+    return [
+        "",
+        `Update available: blitzreels ${update.current} -> ${update.manifest.latest}`,
+        "",
+        "New:",
+        ...update.manifest.changes.slice(0, 3).map((change) => `- ${change}`),
+        "",
+        "Upgrade:",
+        update.manifest.upgrade.npm,
+        `Changelog: ${update.manifest.url}`,
+    ];
+}
+function buildVersionLines({ update }) {
+    const lines = [`blitzreels ${CLI_VERSION}`];
+    if (update.updateAvailable) {
+        lines.push(`Latest: ${update.manifest.latest}`);
+        lines.push("Update available.");
+        lines.push(`Upgrade: ${update.manifest.upgrade.npm}`);
+        lines.push(`Changelog: ${update.manifest.url}`);
+    }
+    else {
+        lines.push(`Latest: ${update.manifest.latest}`);
+        lines.push("Up to date.");
+    }
+    return lines;
+}
+function buildDoctorLines({ context, update, }) {
+    const supported = !isVersionLessThan({
+        left: CLI_VERSION,
+        right: update.manifest.minSupported,
     });
+    const lines = [
+        `CLI: ${CLI_VERSION}`,
+        `Latest: ${update.manifest.latest}`,
+        `Supported: ${supported ? "yes" : "no"}`,
+        `API key: ${context.config.apiKey ? "configured" : "missing"}`,
+        `Base URL: ${context.config.baseUrl ?? "https://www.blitzreels.com/api/v1"}`,
+        `Key storage: ${context.config.keyStorage ?? "none"}`,
+    ];
+    if (update.updateAvailable) {
+        lines.push(`Upgrade: ${update.manifest.upgrade.npm}`);
+        lines.push(`Changelog: ${update.manifest.url}`);
+    }
+    return lines;
+}
+function isVersionLessThan({ left, right, }) {
+    const leftParts = parseSemver({ value: left });
+    const rightParts = parseSemver({ value: right });
+    for (let index = 0; index < 3; index++) {
+        const leftPart = leftParts[index] ?? 0;
+        const rightPart = rightParts[index] ?? 0;
+        if (leftPart < rightPart) {
+            return true;
+        }
+        if (leftPart > rightPart) {
+            return false;
+        }
+    }
+    return false;
+}
+function parseSemver({ value }) {
+    return value
+        .replace(/^v/, "")
+        .split(".", 3)
+        .map((part) => Number.parseInt(part.replace(/\D.*$/, ""), 10))
+        .map((part) => (Number.isFinite(part) ? part : 0));
 }
 async function readJsonResponse({ response, url, action, }) {
     const contentType = response.headers.get("content-type") ?? "";
@@ -1945,23 +3886,6 @@ function parseDeviceTokenResponse({ value, }) {
         key_prefix: typeof record.key_prefix === "string" ? record.key_prefix : undefined,
     };
 }
-async function loadConfig() {
-    try {
-        const raw = await readFile(CONFIG_PATH, "utf8");
-        const value = JSON.parse(raw);
-        const keyStorage = value.keyStorage === "keychain" ? "keychain" : "config";
-        const keychainApiKey = keyStorage === "keychain" ? await readKeychainApiKey() : "";
-        return {
-            apiKey: keychainApiKey ||
-                (typeof value.apiKey === "string" ? value.apiKey : ""),
-            baseUrl: typeof value.baseUrl === "string" ? value.baseUrl : undefined,
-            keyStorage,
-        };
-    }
-    catch {
-        return { apiKey: "", baseUrl: undefined, keyStorage: undefined };
-    }
-}
 function parseArgs({ argv }) {
     const command = [];
     const flags = {};
@@ -1995,39 +3919,81 @@ function validateParsedArgs({ parsed }) {
     if (!spec) {
         throw buildUnknownCommandError({ command: parsed.command });
     }
-    const allowedFlags = new Set([...GLOBAL_FLAGS, ...spec.flags]);
+    const allowedFlags = new Set([
+        ...GLOBAL_FLAGS,
+        ...spec.flags.map((flag) => flag.name),
+    ]);
     for (const flag of Object.keys(parsed.flags)) {
         if (!allowedFlags.has(flag)) {
             throw buildUnknownFlagError({ spec, flag });
         }
     }
+    if (getBooleanFlag({ flags: parsed.flags, name: "dry-run" }) &&
+        !spec.dryRunSupported) {
+        throw new CliUsageError({
+            code: "unsupported_dry_run",
+            message: "--dry-run is not supported for this command.",
+            usage: spec.usage,
+        });
+    }
 }
 function findCommandSpec({ command, }) {
     return COMMAND_SPECS.find((spec) => commandsEqual(spec.command, command));
 }
-function commandsEqual(left, right) {
-    return (left.length === right.length &&
-        left.every((part, index) => part === right[index]));
-}
-function commandLabel({ command }) {
-    return command.join(" ");
-}
-function printCommandHelpOrThrow({ command }) {
+function printCommandOrGroupHelpOrThrow({ command, }) {
     const spec = findCommandSpec({ command });
-    if (!spec) {
-        throw buildUnknownCommandError({ command });
+    if (spec) {
+        printCommandHelp({ spec });
+        return;
+    }
+    const groupSpecs = findGroupCommandSpecs({ command });
+    if (groupSpecs.length > 0) {
+        printGroupHelp({ command, specs: groupSpecs });
+        return;
     }
-    printCommandHelp({ spec });
+    throw buildUnknownCommandError({ command });
 }
 function printCommandHelp({ spec }) {
-    const flags = [...new Set([...spec.flags, ...GLOBAL_FLAGS])].sort();
+    const flags = flagsForCommand({ spec });
+    const agentHelp = isAgentHelpEnvironment()
+        ? `\nAgent instructions:\n  blitzreels prime --command ${JSON.stringify(commandLabel({ command: spec.command }))}\n  blitzreels agent-context --command ${JSON.stringify(commandLabel({ command: spec.command }))} --json\n`
+        : "";
     console.log(`Usage:
   ${spec.usage}
 
+Description:
+  ${spec.description}
+
 Flags:
-${flags.map((flag) => `  --${flag}`).join("\n")}
+${flags
+        .map((flag) => {
+        const required = flag.required ? " required" : "";
+        const values = flag.enum ? ` (${flag.enum.join("|")})` : "";
+        const defaultValue = flag.default === undefined ? "" : ` default=${String(flag.default)}`;
+        return `  --${flag.name} ${flag.type}${required}${values}${defaultValue}  ${flag.description}`;
+    })
+        .join("\n")}
+
+Examples:
+${spec.examples.map((example) => `  ${example}`).join("\n")}
+${agentHelp}
 `);
 }
+function isAgentHelpEnvironment() {
+    const truthyEnv = [
+        "BLITZREELS_AGENT_HELP",
+        "CODEX_SHELL",
+        "CLAUDECODE",
+        "CLAUDE_CODE",
+        "CURSOR_AGENT",
+        "OPENCODE",
+        "AIDER",
+    ];
+    return truthyEnv.some((name) => {
+        const value = process.env[name];
+        return value !== undefined && value !== "" && value !== "0";
+    });
+}
 function buildUnknownCommandError({ command, }) {
     const suggestions = suggestCommands({ command }).map((spec) => spec.usage);
     return new CliUsageError({
@@ -2037,8 +4003,38 @@ function buildUnknownCommandError({ command, }) {
         usage: suggestions[0],
     });
 }
+function findGroupCommandSpecs({ command, }) {
+    if (command.length === 0) {
+        return [];
+    }
+    return COMMAND_SPECS.filter((spec) => commandsEqual(spec.command.slice(0, command.length), command));
+}
+function printGroupHelp({ command, specs, }) {
+    const label = commandLabel({ command });
+    const agentHelp = isAgentHelpEnvironment()
+        ? `\nAgent instructions:\n  blitzreels prime --command ${JSON.stringify(label)}\n  blitzreels agent-context --command ${JSON.stringify(label)} --json\n`
+        : "";
+    console.log(`blitzreels ${label}
+
+Available commands:
+${specs.map((spec) => `  ${spec.usage}`).join("\n")}
+
+Examples:
+${specs
+        .slice(0, 4)
+        .flatMap((spec) => spec.examples.slice(0, 1))
+        .map((example) => `  ${example}`)
+        .join("\n")}
+${agentHelp}
+`);
+}
 function buildUnknownFlagError({ spec, flag, }) {
-    const flags = [...new Set([...spec.flags, ...GLOBAL_FLAGS])];
+    const flags = [
+        ...new Set([
+            ...spec.flags.map((candidate) => candidate.name),
+            ...GLOBAL_FLAGS,
+        ]),
+    ];
     const suggestions = suggestValues({ value: flag, candidates: flags }).map((candidate) => `--${candidate}`);
     return new CliUsageError({
         code: "unknown_flag",
@@ -2048,55 +4044,7 @@ function buildUnknownFlagError({ spec, flag, }) {
     });
 }
 function suggestCommands({ command }) {
-    const joined = commandLabel({ command });
-    const prefixMatches = COMMAND_SPECS.filter((spec) => commandsEqual(spec.command.slice(0, command.length), command));
-    if (prefixMatches.length > 0) {
-        return prefixMatches.slice(0, 3);
-    }
-    return COMMAND_SPECS.map((spec) => ({
-        spec,
-        score: commandSimilarity({
-            left: joined,
-            right: commandLabel({ command: spec.command }),
-        }),
-    }))
-        .filter((item) => item.score >= 0.45)
-        .sort((left, right) => right.score - left.score)
-        .slice(0, 3)
-        .map((item) => item.spec);
-}
-function suggestValues({ value, candidates, }) {
-    return candidates
-        .map((candidate) => ({
-        candidate,
-        score: commandSimilarity({ left: value, right: candidate }),
-    }))
-        .filter((item) => item.score >= 0.45)
-        .sort((left, right) => right.score - left.score)
-        .slice(0, 3)
-        .map((item) => item.candidate);
-}
-function commandSimilarity({ left, right, }) {
-    const maxLength = Math.max(left.length, right.length);
-    if (maxLength === 0) {
-        return 1;
-    }
-    return 1 - levenshteinDistance({ left, right }) / maxLength;
-}
-function levenshteinDistance({ left, right, }) {
-    const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
-    const current = Array.from({ length: right.length + 1 }, () => 0);
-    for (let leftIndex = 1; leftIndex <= left.length; leftIndex++) {
-        current[0] = leftIndex;
-        for (let rightIndex = 1; rightIndex <= right.length; rightIndex++) {
-            const substitutionCost = left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1;
-            current[rightIndex] = Math.min((current[rightIndex - 1] ?? 0) + 1, (previous[rightIndex] ?? 0) + 1, (previous[rightIndex - 1] ?? 0) + substitutionCost);
-        }
-        for (let index = 0; index < previous.length; index++) {
-            previous[index] = current[index] ?? 0;
-        }
-    }
-    return previous[right.length] ?? 0;
+    return suggestCommandSpecs({ command, specs: COMMAND_SPECS });
 }
 function usageForCurrentCommand() {
     const parsed = parseArgs({ argv: process.argv.slice(2) });
@@ -2222,16 +4170,92 @@ function parseStringRecordFlag({ flags, name, }) {
     }
     return value;
 }
-function requireConfirmPreview({ flags }) {
-    if (!getBooleanFlag({ flags, name: "confirm-preview" })) {
-        throw new Error("Destructive edits require --confirm-preview after reviewing a plan.");
+function getTimelineStartFlag({ flags }) {
+    const value = getStringFlag({ flags, name: "at" });
+    return value === undefined ? undefined : parseTimecode({ value });
+}
+function parseEffectEasing({ value, }) {
+    if (value === undefined) {
+        return undefined;
     }
-    return true;
+    if (value === "linear" ||
+        value === "easeIn" ||
+        value === "easeOut" ||
+        value === "easeInOut") {
+        return value;
+    }
+    throw new Error("--easing must be linear, easeIn, easeOut, or easeInOut.");
+}
+function parseZoomStyle({ value, }) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "transition" || value === "hard") {
+        return value;
+    }
+    throw new Error("--style must be transition or hard.");
+}
+function parseZoomPhase({ value, }) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "in" ||
+        value === "out" ||
+        value === "both" ||
+        value === "none") {
+        return value;
+    }
+    throw new Error("--phase must be in, out, both, or none.");
 }
-function requireConfirmDelete({ flags }) {
-    if (!getBooleanFlag({ flags, name: "confirm-delete" })) {
-        throw new Error("Delete commands require --confirm-delete.");
+function maybePoint({ x, y, }) {
+    if (x === undefined && y === undefined) {
+        return undefined;
     }
+    return { x: x ?? 0, y: y ?? 0 };
+}
+function buildZoomEffectSettings({ flags, durationSeconds, }) {
+    const fromJson = parseJsonObjectFlag({ flags, name: "settings-json" });
+    const scaleStart = getNumberFlag({ flags, name: "scale-start" });
+    const scaleEnd = getNumberFlag({ flags, name: "scale-end" });
+    const translateStart = maybePoint({
+        x: getNumberFlag({ flags, name: "translate-start-x" }),
+        y: getNumberFlag({ flags, name: "translate-start-y" }),
+    });
+    const translateEnd = maybePoint({
+        x: getNumberFlag({ flags, name: "translate-end-x" }),
+        y: getNumberFlag({ flags, name: "translate-end-y" }),
+    });
+    const anchor = maybePoint({
+        x: getNumberFlag({ flags, name: "anchor-x" }),
+        y: getNumberFlag({ flags, name: "anchor-y" }),
+    });
+    return {
+        ...(fromJson ?? {}),
+        scale: scaleStart === undefined && scaleEnd === undefined
+            ? fromJson?.scale
+            : {
+                start: scaleStart ?? 1,
+                end: scaleEnd ?? scaleStart ?? 1,
+            },
+        translate: translateStart === undefined && translateEnd === undefined
+            ? fromJson?.translate
+            : {
+                start: translateStart ?? { x: 0, y: 0 },
+                end: translateEnd ?? translateStart ?? { x: 0, y: 0 },
+            },
+        anchor: anchor ?? fromJson?.anchor,
+        style: parseZoomStyle({ value: getStringFlag({ flags, name: "style" }) }) ??
+            fromJson?.style,
+        phase: parseZoomPhase({ value: getStringFlag({ flags, name: "phase" }) }) ??
+            fromJson?.phase,
+        inDurationSeconds: getNumberFlag({ flags, name: "in-duration" }) ??
+            durationSeconds ??
+            fromJson?.inDurationSeconds,
+        outDurationSeconds: parseNullableNumberFlag({ flags, name: "out-duration" }) ??
+            fromJson?.outDurationSeconds,
+        outScale: parseNullableNumberFlag({ flags, name: "out-scale" }) ??
+            fromJson?.outScale,
+    };
 }
 function parseTimecode({ value }) {
     const trimmed = value.trim();
@@ -2267,75 +4291,11 @@ function openBrowser({ url }) {
     });
     child.unref();
 }
-function canUseKeychain() {
-    return (process.platform === "darwin" &&
-        process.env.BLITZREELS_DISABLE_KEYCHAIN !== "1");
-}
-function runSecurity({ args, }) {
-    return new Promise((resolveCommand) => {
-        const child = spawn("security", args, {
-            stdio: ["ignore", "pipe", "ignore"],
-        });
-        const chunks = [];
-        child.stdout.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-        child.on("error", () => resolveCommand({ stdout: "", ok: false }));
-        child.on("close", (code) => resolveCommand({
-            stdout: Buffer.concat(chunks).toString("utf8").trim(),
-            ok: code === 0,
-        }));
-    });
-}
 function sleep({ ms }) {
     return new Promise((resolveSleep) => {
         setTimeout(resolveSleep, ms);
     });
 }
-async function saveApiKey({ apiKey }) {
-    if (!canUseKeychain()) {
-        return false;
-    }
-    const result = await runSecurity({
-        args: [
-            "add-generic-password",
-            "-a",
-            KEYCHAIN_ACCOUNT,
-            "-s",
-            KEYCHAIN_SERVICE,
-            "-w",
-            apiKey,
-            "-U",
-        ],
-    });
-    return result.ok;
-}
-async function readKeychainApiKey() {
-    if (!canUseKeychain()) {
-        return "";
-    }
-    const result = await runSecurity({
-        args: [
-            "find-generic-password",
-            "-a",
-            KEYCHAIN_ACCOUNT,
-            "-s",
-            KEYCHAIN_SERVICE,
-            "-w",
-        ],
-    });
-    return result.ok ? result.stdout : "";
-}
-async function persistLoggedInApiKey({ apiKey, baseUrl, }) {
-    const savedToKeychain = await saveApiKey({ apiKey });
-    const config = {
-        apiKey: savedToKeychain ? "" : apiKey,
-        baseUrl,
-        keyStorage: savedToKeychain ? "keychain" : "config",
-    };
-    await mkdir(dirname(CONFIG_PATH), { recursive: true });
-    await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), {
-        mode: 0o600,
-    });
-}
 function parseImageFormat({ value, }) {
     if (value === undefined) {
         return undefined;
@@ -2388,6 +4348,110 @@ function parseAssetType({ value, }) {
     }
     throw new Error("--asset-type must be video, audio, image, document, or all.");
 }
+function parseAudioLibraryProviderFilter({ value, }) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "all" ||
+        value === "openverse" ||
+        value === "freesound" ||
+        value === "wikimedia") {
+        return value;
+    }
+    throw new Error("--provider must be all, openverse, freesound, or wikimedia.");
+}
+function parseAudioLibraryProvider({ value, }) {
+    const parsed = parseAudioLibraryProviderFilter({ value });
+    if (parsed === "openverse" ||
+        parsed === "freesound" ||
+        parsed === "wikimedia") {
+        return parsed;
+    }
+    throw new Error("--provider must be openverse, freesound, or wikimedia.");
+}
+function parseAudioLibraryLicense({ value, }) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "cc0" ||
+        value === "public_domain" ||
+        value === "attribution" ||
+        value === "all") {
+        return value;
+    }
+    throw new Error("--license must be cc0, public_domain, attribution, or all.");
+}
+function parseAudioLibraryType({ value, }) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "music" ||
+        value === "sound_effect" ||
+        value === "ambient" ||
+        value === "other") {
+        return value;
+    }
+    throw new Error("--audio-type must be music, sound_effect, ambient, or other.");
+}
+function parseStockProvider({ value, }) {
+    if (value === undefined) {
+        return null;
+    }
+    if (value === "pexels" || value === "freesound") {
+        return value;
+    }
+    throw new Error("--provider must be pexels or freesound.");
+}
+function parseRequiredStockProvider({ value, }) {
+    const parsed = parseStockProvider({ value });
+    if (parsed !== null) {
+        return parsed;
+    }
+    throw new Error("--provider must be pexels or freesound.");
+}
+function parseStockAssetType({ value, }) {
+    if (value === "image" || value === "video" || value === "audio") {
+        return value;
+    }
+    throw new Error("--asset-type must be image, video, or audio.");
+}
+function parseNullableStockAssetType({ value, }) {
+    return value === undefined ? null : parseStockAssetType({ value });
+}
+function parseStockOrientation({ value, }) {
+    if (value === undefined) {
+        return null;
+    }
+    if (value === "landscape" || value === "portrait" || value === "square") {
+        return value;
+    }
+    throw new Error("--orientation must be landscape, portrait, or square.");
+}
+function parseStockAudioType({ value, }) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "sound_effect" ||
+        value === "ambient" ||
+        value === "background_music" ||
+        value === "other") {
+        return value;
+    }
+    throw new Error("--audio-type must be sound_effect, ambient, background_music, or other.");
+}
+function parseGlobalBrollAudioType({ value, }) {
+    if (value === undefined) {
+        return null;
+    }
+    if (value === "music" ||
+        value === "sound_effect" ||
+        value === "ambient" ||
+        value === "background_music" ||
+        value === "other") {
+        return value;
+    }
+    throw new Error("--audio-type must be music, sound_effect, ambient, background_music, or other.");
+}
 function parseYoutubeQuality({ value, }) {
     if (value === undefined) {
         return undefined;
@@ -2409,10 +4473,13 @@ function parseMediaPositionPreset({ value, }) {
         value === "top-right" ||
         value === "bottom-left" ||
         value === "bottom-right" ||
-        value === "full-screen") {
+        value === "fullscreen") {
         return value;
     }
-    throw new Error("--position-preset must be center, top-left, top-right, bottom-left, bottom-right, or full-screen.");
+    if (value === "full-screen") {
+        return "fullscreen";
+    }
+    throw new Error("--position-preset must be center, top-left, top-right, bottom-left, bottom-right, fullscreen, or full-screen.");
 }
 function parseMediaAnimationPreset({ value, }) {
     if (value === undefined) {
@@ -2422,13 +4489,32 @@ function parseMediaAnimationPreset({ value, }) {
         value === "fadeIn" ||
         value === "fadeOut" ||
         value === "zoomIn" ||
+        value === "zoomOut" ||
         value === "slideIn" ||
+        value === "slideLeft" ||
+        value === "slideRight" ||
+        value === "slideUp" ||
+        value === "slideDown" ||
         value === "popIn" ||
         value === "bounce" ||
         value === "spin") {
         return value;
     }
-    throw new Error("--animation-preset must be none, fadeIn, fadeOut, zoomIn, slideIn, popIn, bounce, or spin.");
+    throw new Error("--animation-preset must be none, fadeIn, fadeOut, zoomIn, zoomOut, slideIn, slideLeft, slideRight, slideUp, slideDown, popIn, bounce, or spin.");
+}
+function toApiMediaPositionPreset({ value, }) {
+    if (value === "top-left")
+        return "pip-top-left";
+    if (value === "top-right")
+        return "pip-top-right";
+    if (value === "bottom-left")
+        return "pip-bottom-left";
+    if (value === "bottom-right")
+        return "pip-bottom-right";
+    return value;
+}
+function toApiMediaAnimationPreset({ value, }) {
+    return value === "slideIn" ? "slideUp" : value;
 }
 function parseCaptionMatchPattern({ value, }) {
     if (value === undefined) {
@@ -2782,6 +4868,17 @@ function buildCaptionWordSelector({ flags }) {
             value: getStringFlag({ flags, name: "match-pattern" }),
         }),
         timelineItemId: getStringFlag({ flags, name: "timeline-item-id" }),
+        all: getOptionalBooleanFlag({ flags, name: "all" }),
+        fromSeconds: getStringFlag({ flags, name: "from" }) === undefined
+            ? undefined
+            : parseTimecode({
+                value: requireStringFlag({ flags, name: "from" }),
+            }),
+        toSeconds: getStringFlag({ flags, name: "to" }) === undefined
+            ? undefined
+            : parseTimecode({
+                value: requireStringFlag({ flags, name: "to" }),
+            }),
     };
 }
 function buildCaptionWordStyleFromFlags({ flags, }) {
@@ -2876,6 +4973,58 @@ function buildCaptionWordStyleFromFlags({ flags, }) {
     }
     return style;
 }
+function buildCaptionThemeSettingsPatch({ flags, }) {
+    const settingsJson = parseJsonObjectFlag({ flags, name: "settings-json" });
+    if (settingsJson !== undefined) {
+        return settingsJson;
+    }
+    const settings = {};
+    setIfDefined({
+        target: settings,
+        key: "textShadow",
+        value: getStringFlag({ flags, name: "text-shadow" }),
+    });
+    setIfDefined({
+        target: settings,
+        key: "shadowMode",
+        value: parseCaptionShadowMode({
+            value: getStringFlag({ flags, name: "shadow-mode" }),
+        }),
+    });
+    setIfDefined({
+        target: settings,
+        key: "textStrokeEnabled",
+        value: getOptionalBooleanFlag({ flags, name: "text-stroke-enabled" }),
+    });
+    setIfDefined({
+        target: settings,
+        key: "textStrokeColor",
+        value: getStringFlag({ flags, name: "text-stroke-color" }),
+    });
+    setIfDefined({
+        target: settings,
+        key: "textStrokeWidthPx",
+        value: getNumberFlag({ flags, name: "text-stroke-width-px" }),
+    });
+    setIfDefined({
+        target: settings,
+        key: "textStrokeBlurPx",
+        value: getNumberFlag({ flags, name: "text-stroke-blur-px" }),
+    });
+    return Object.keys(settings).length === 0 ? undefined : settings;
+}
+function parseCaptionShadowMode({ value, }) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "null") {
+        return null;
+    }
+    if (value === "text-shadow" || value === "drop-shadow") {
+        return value;
+    }
+    throw new Error("--shadow-mode must be text-shadow, drop-shadow, or null.");
+}
 function setIfDefined({ target, key, value, }) {
     if (value !== undefined) {
         target[key] = value;
@@ -2896,14 +5045,28 @@ function requireApiKey({ apiKey }) {
         throw new Error("Missing API key. Run `blitzreels auth login`, `blitzreels auth set-key --api-key ...`, or set BLITZREELS_API_KEY.");
     }
 }
-function printResult({ json, value, human, }) {
+function printResult({ json, value, human, fields, }) {
     if (json) {
-        console.log(JSON.stringify(value, null, 2));
+        const selectedFields = fields ??
+            parseCsvFlag({
+                flags: parseArgs({ argv: process.argv.slice(2) }).flags,
+                name: "fields",
+            });
+        console.log(JSON.stringify(selectedFields && selectedFields.length > 0
+            ? applyFieldSelection({ value, fields: selectedFields })
+            : value, null, 2));
         return;
     }
     console.log(human.join("\n"));
 }
 function printHelp() {
+    const agentHelp = isAgentHelpEnvironment()
+        ? `
+Agent instructions:
+  blitzreels prime
+  blitzreels agent-context --json
+`
+        : "";
     console.log(`blitzreels
 
 Usage:
@@ -2913,6 +5076,7 @@ Global flags:
   --api-key KEY
   --base-url URL
   --json
+${agentHelp}
 `);
 }
 main().catch((error) => {