@officexapp/vidfarm-devcli 0.21.31 → 0.21.33

package/dist/src/cli.js

@@ -22,6 +22,7 @@ import { renderCompositionStills } from "./devcli/stills.js";
 import { extractCompositionFacts, formatQaReport, qaCompositionHtml } from "./devcli/qa-check.js";
 import { discoverRegime, formatRegimeReport, listBuiltinRegimes, loadAndEvaluateRegime, mergeRegimeIntoReport, parseRegime, resolveRegimePath } from "./devcli/qa-regime.js";
 import { removeGreenscreenLocal, localGreenscreenAvailable, defaultGreenscreenOutPath, GREENSCREEN_PRESETS, trimTransparentBorders, cropImageRegion } from "./devcli/greenscreen-local.js";
+import { dedupeMediaLocal, localDedupeAvailable, defaultDedupeOutPath, describeLocalDedupe, DEDUPE_PRESETS, DEDUPE_DEFAULT_PRESET, isDedupePresetName } from "./devcli/dedupe-local.js";
 import { segmentAlphaComponents, encodeTransparentGif, encodeTransparentAnimatedGif, pickPlateColor, detectPlateColor, keySafeArtInstruction, analyzeKeyedArt, HOLE_WARN_PCT } from "./devcli/sticker-pack.js";
 import { runDoctorCommand } from "./devcli/doctor.js";
 import { findFreePort } from "./devcli/port-utils.js";
@@ -329,6 +330,38 @@ Generate AI media and drop it on the timeline (for local coding agents):
     --cloud                 Force the billed cloud primitive
     --out <file>            Write the transparent result to this path (local writes
                             <source>.transparent.png/.webm next to it by default)
+  dedupe <video|image|url>  DEDUPLICATE a finished render so a re-post reads as a
+                            NEW upload instead of tripping a platform's duplicate-
+                            content check. Invisible to a viewer. Runs on the
+                            EXPORTED file — no second render.
+                            (aliases: dedup, deduplicate, uniquify)
+                            → POST /api/v1/primitives/media/dedupe
+    --preset <name>         none | light | standard | strong | legacy
+                            standard (default) = skew 2%, zoom 3%, rotate 2°,
+                            speed +2%, saturation +4%, +contrast/brightness/hue/grain
+    --variants <n>          Mint N mutually-distinct copies in one pass (variant 1
+                            is the preset as authored; later variants get jittered
+                            magnitudes and flipped signs). One per account/slot.
+    --variant <n>           Start numbering here (resume a batch); --seed <s> for
+                            extra entropy so two batches of one source diverge
+    --no-jitter             Apply the preset verbatim to every variant
+    --zoom/--rotate/--skew/--tilt/--speed/--saturation/--contrast/--brightness/
+    --hue/--blur/--noise/--volume   Override any single knob (beats the preset)
+    --flip                  Mirror horizontally. Strongest single knob, but it
+                            visibly reverses on-screen text — opt in deliberately.
+    --effects-json '{...}'  Set several knobs at once
+    --tint-color/--tint-opacity   Flat color wash over the frame (default off)
+    --width/--height        Force an output size (default: keep the source's)
+    --crf <n>               Base x264 quality; jittered ±1 per variant
+    --keep-metadata         Don't strip container metadata (creation time,
+                            encoder, source handler) — stripping is the default
+    --media-type <k>        Force image|video instead of auto-detecting
+    --output-format <f>     Image only: png|jpeg|webp
+    --local                 Dedupe on your machine with bundled ffmpeg for FREE
+                            (no wallet, no account; cloud-parity) — DEFAULT
+    --cloud                 Force the billed cloud primitive
+    --out <file>            Single-variant output path (default <source>.dedupe.<ext>)
+    --out-dir <dir>         Where to write batch variants
   cutout <image|url>        Make a transparent explainer STICKER: key out the flat
                             plate, then trim the canvas down to the cutout's true
                             min width/height. Local, free, ffmpeg-only. Image-only.
@@ -740,8 +773,16 @@ Approve & schedule (publish a finished MP4 as a shareable post):
                             (add --temp only for a disposable 30-day preview.)
   posts                     List your approved posts                     → GET  /api/v1/approved/posts
   post <postId>             Read one approved post (prints share URL)    → GET  /api/v1/approved/posts/:postId
+  channels                  List destinations you can schedule to        → GET  /api/v1/user/me/channels
   schedule <postId>         Schedule an approved post to a channel       → POST /api/v1/approved/posts/:postId/schedules
+    --at <iso>             When to send (ISO 8601, min 10 min from now)
+    --to <destination>     Channel id, email address, or @handle — all resolve
+                           server-side, so 'vidfarm channels' is optional
+    --type email|flockposter   Destination kind (default flockposter)
   schedules <postId>        Browse an approved post's schedules          → GET  /api/v1/approved/posts/:postId/schedules
+  reschedule <postId> <scheduleId>  Move a queued send                  → PATCH  /api/v1/approved/posts/:postId/schedules/:scheduleId
+  unschedule <postId> <scheduleId>  Cancel a queued send                → DELETE /api/v1/approved/posts/:postId/schedules/:scheduleId
+                            An error here means the send was NOT stopped.
 
 Account:
   login <email>             Send an OTP code to email                    → POST /api/v1/user/request-otp
@@ -876,7 +917,8 @@ Cost spectrum (default to the cheapest approach that works; see SKILL.director.m
   command (generate, music, decompose, cloud render/TTS/STT/greenscreen, create, replicate)
   respects it: minimize refuses billed spend without --yes and points you at the free
   local path; the others run but print each op's cost. FREE local engines never gate
-  (local render, tts --engine local, stt --engine whisper, remove-greenscreen --local).
+  (local render, tts --engine local, stt --engine whisper, remove-greenscreen --local,
+   dedupe --local).
   In minimize AND hybrid, 'vidfarm tts' DEFAULTS to the free local Kokoro voice — ask for
   a premium voice (--style/--voice/--provider/--own-key/--cloud), or be in rich-ai /
   pure-videogen, to opt out.
@@ -1052,6 +1094,12 @@ async function main() {
         case "greenscreen":
             await runRemoveGreenscreenCommand(rest);
             return;
+        case "dedupe":
+        case "dedup":
+        case "deduplicate":
+        case "uniquify":
+            await runDedupeCommand(rest);
+            return;
         case "cutout":
         case "sticker":
             await runCutoutCommand(rest);
@@ -1134,12 +1182,21 @@ async function main() {
         case "post":
             await runPostCommand(rest);
             return;
+        case "channels":
+            await runChannelsCommand(rest);
+            return;
         case "schedule":
             await runScheduleCommand(rest);
             return;
         case "schedules":
             await runSchedulesCommand(rest);
             return;
+        case "reschedule":
+            await runRescheduleCommand(rest);
+            return;
+        case "unschedule":
+            await runUnscheduleCommand(rest);
+            return;
         case "login":
             await runLoginCommand(rest);
             return;
@@ -2330,10 +2387,11 @@ Rules:
 - When swapping visuals, match both the literal scene DNA and the narrative purpose of the beat.
 - For replacement graphics, screenshots, or still-like scenes, prefer AI image generation plus Ken Burns before paying for AI video unless static_vs_pivot says motion footage is load-bearing.
 - If narration must be customized, default to premium ElevenLabs first, then the user's own ElevenLabs path, then BYOK OpenAI/Gemini/OpenRouter. If captions or scenes were timed to the old VO, retime them to the new narration.
-- NO HTML SLOP. You are editing HTML, but the output is a social video, not a web page. Never author landing-page furniture: CTA "buttons" (a filled/gradient rounded capsule with action copy like "Sign Up for a Free Trial →"), benefit chip/badge rows ("✓ No Credit Card Needed"), bordered/shadowed/frosted cards holding a headline + URL, gradient text fills, feature grids, bulleted lists, or web-default fonts (Inter/Roboto/Arial/system-ui). None of that appears in a real TikTok, and nothing in a video is clickable — say it as timed text on the footage instead. Arrows, scribble/underline marks, italics, ALL-CAPS, single-word color pops, emoji, transparent cut-out stickers, and mock social UI (iMessage bubbles, comment cards) are all fine. Captions use an imported family (Montserrat default / TikTok Sans / Abel / Source Code Pro / Yesteryear) at weight 700-900, ~36-64px on a 1080-wide frame, inside the 8%-85% safe zone, with exactly one of four backgrounds: outline, plain, an active-word spotlight/karaoke pill, or a tight-hugging solid band (radius <=8px, no border/shadow/gradient/blur).
+- NO HTML SLOP. You are editing HTML, but the output is a social video, not a web page. THE TEST IS THE NATIVE-EDITOR TEST: could you have made this element with the tools inside TikTok's own editor? That toolset is a font, a color, a stroke/outline, a soft shadow, a tight text box, alignment, opacity, rotation, animation presets — plus stickers, emoji, drawn marks and clips. It has NO padded capsule, NO border, NO gradient fill, NO blur panel, NO card. If you reached past it, cut it. Never author landing-page furniture: CTA "buttons" (a filled/gradient rounded capsule with action copy like "Sign Up for a Free Trial →"), benefit chip/badge rows ("✓ No Credit Card Needed"), bordered/shadowed/frosted cards holding a headline + URL, gradient text fills, feature grids, bulleted lists, or web-default fonts (Inter/Roboto/Arial/system-ui). AND NOT A SINGLE PILL EITHER: one lonely rounded, padded, filled capsule around a static stat or label — "10 hrs / week", "STEP 2", "EP.01", "+40%" — is a web badge, and being the only one on screen does not make it native. The ONLY legitimate capsule in a video is the active-word spotlight/karaoke caption highlight, because it moves with the spoken word. Emphasize a stat the way the editor would: bigger, heavier, ALL-CAPS, an accent color, a hand-drawn circle or underline, or its own beat on screen. Rule of thumb on anything holding words: border-radius over ~8px PLUS a background fill PLUS padding = a badge; drop the fill or drop the radius until the band hugs the glyphs. None of this appears in a real TikTok, and nothing in a video is clickable — say it as timed text on the footage instead. Arrows, scribble/underline marks, italics, ALL-CAPS, single-word color pops, emoji, transparent cut-out stickers, and mock social UI (iMessage bubbles, comment cards) are all fine. Captions use an imported family (Montserrat default / TikTok Sans / Abel / Source Code Pro / Yesteryear) at weight 700-900, ~36-64px on a 1080-wide frame, inside the 8%-85% safe zone, with exactly one of four backgrounds: outline, plain, an active-word spotlight/karaoke pill, or a tight-hugging solid band (radius <=8px, no border/shadow/gradient/blur).
 - STRUCTURE BEFORE POLISH — THE FOUR CHARGES, WRITTEN BEFORE YOU TOUCH THE TIMELINE. Most agent-made videos fail on structure, not polish, because the timeline is the fun part so it gets built first and the words get retrofitted. Invert it: (1) HOOK — write the opening line as text first: a complete clause (subject + verb), no jargon, naming a SITUATION ("I've quit six businesses") not a label ("anonymity"); it goes on screen at start:0, because caption chunk 1 is read before any audio and muted autoplay is the default. Banned openings: throat-clearing ("so I was thinking", "here's the thing"), a logo, a title card, a fade from black, context before the claim. (2) LOOP — one open question by 0:10, said ON SCREEN, closing INSIDE this video (state the timestamp it closes at; if you can't, there is no loop), and the withheld answer must be one the viewer CANNOT supply themselves — a formally-correct loop with a guessable answer passes every mechanical check and dies in the field. (3) PAYOFF — shown, not summarized, ≥5 uninterrupted seconds, landing BEFORE the final beat; the payoff is not the CTA. (4) BAIT — one ask in the final beat and in the post caption; never a DM funnel, "follow for part two", or ragebait. Then build the timeline. Re-theming a decomposed template: viral_dna already names the source's hook/retention/payoff — rebuild each charge for the new subject, never flatten the loop into a product statement. Full craft harness: the vidfarm skill's references/hooks-and-virality.md. Checkable form: \`vidfarm regime show hooks\`.
 - THE FIRST FRAME IS THE THUMBNAIL. Frame 0 is one frame of ~30 in the first second, but every feed card, share link, and paused player freezes on it — more people see that frame than watch the video. It must never be black, empty, mid-fade, or mid-animation: a real visual at start:0 (\`vidfarm retime . --layer <key> --start 0\`), the hook words already on screen at t=0, and NO entrance transition on the FIRST clip (\`vidfarm transitions set . --layer <key> --in none\`; junction transitions between later clips are fine). Look at the actual pixels before you render: \`vidfarm stills . --at 0\`.
 - ONE-TIME OR BULK? Ask before you build. If the director wants volume (daily posting, N variants, hook tests), that's SCRIPTING MODE: pin this fork as the base, vary exactly ONE thing per variant, and install a QA_REGIME.md — \`vidfarm regime init short-form --out ./QA_REGIME.md\` (bases: short-form, hooks, ugc-testimonial, explainer, product-demo), then EDIT it with them. It is their own written quality standard, and it exists because nobody watches variant #37 as carefully as #1. \`vidfarm qa .\` picks up ./QA_REGIME.md automatically; \`--regime <name|path>\` adds more (they stack, and any file of theirs anywhere is valid). Its \`checks:\` are machine-settled; its \`- [ ]\` items come back for YOU to answer honestly in your report — never claim a pass on the half the CLI can't judge. When a batch teaches you something, write it back into the regime.
+- DEDUPLICATE BEFORE YOU PUBLISH — AND ASK FIRST. Social platforms fingerprint every upload, so the same render posted twice (a second account, another platform, a re-post next month) gets the later copy suppressed as duplicate/reused content. BEFORE you render for publication, and before any bulk run, ASK the director: "do you want deduplicated copies for posting, and how many?" Ask THEN, not after — dedupe is a post-render ffmpeg pass, so the correct order is RENDER ONCE → DEDUPE N, and deciding late means paying for a second render. Run it on the EXPORTED file: \`vidfarm dedupe ./final.mp4\` (one copy) or \`vidfarm dedupe ./final.mp4 --variants N --seed <slug> --out-dir ./posts\` (N copies, one per account/slot). Free, offline, no wallet — it never re-renders the composition. The default \`standard\` preset is skew 2%, zoom 3%, rotate 2°, speed +2%, saturation +4%, plus contrast/brightness/hue/grain, a container-metadata strip and a per-variant CRF walk; invisible to a viewer, and each variant differs from the original AND from its siblings. Post each variant to a DIFFERENT account — two accounts posting the same variant defeats the point. A rotate forces a bigger centre-crop to hide the black corners (~6.7% on a tall frame at 2°) and the CLI says so; pass \`--rotate 0\` when framing matters more. Cloud twin: \`POST /api/v1/primitives/media/dedupe\`.
 - QA EVERY VIDEO BEFORE YOU RENDER: run \`vidfarm qa .\` in this directory. It's free, instant, and local — a blocklist for the slop above plus the first frame, the font regime, and the safe zone, with a concrete fix per finding. It's feedback, not a gate (exits 0 even on findings, never runs automatically) and a blocklist, not an allowlist, so stylized or hand-made work passes untouched. Fix what's real, ignore what's a deliberate style call. \`--json\` for scripted batches.
 
 The three paintbrushes (Vidfarm is thrift-first — do NOT spend AI credits on every scene):
@@ -5305,6 +5363,354 @@ async function runLocalGreenscreen(ctx, values, sourceArg, presetRaw) {
             rmSync(downloadDir, { recursive: true, force: true });
     }
 }
+// ── dedupe: make a re-post read as a NEW upload ──────────────────────────────
+// Social platforms fingerprint every upload. Posting the same render twice —
+// across accounts, or again next month — gets the later copy suppressed as
+// duplicate/reused content. `vidfarm dedupe` applies a calibrated, invisible
+// perturbation (skew, zoom, rotate, speed, saturation/contrast/brightness/hue,
+// grain, optional tint/mirror) plus a metadata strip and a per-variant CRF walk,
+// so each copy carries a distinct fingerprint.
+//
+// LOCAL by default: it is a pure ffmpeg pass, so it is FREE and offline and does
+// NOT require re-rendering the composition — dedupe the finished MP4 you already
+// paid to render instead of burning a second render.
+//
+// `--variants N` mints N mutually-distinct copies in one go (variant 1 is the
+// preset as authored; later variants get jittered magnitudes and flipped signs),
+// which is the shape bulk posting actually needs.
+function resolveDedupeTarget(values) {
+    if (values.local)
+        return "local";
+    if (values.cloud)
+        return "cloud";
+    const env = (process.env.VIDFARM_TARGET ?? "").trim().toLowerCase();
+    if (env === "local" || env === "cloud")
+        return env;
+    // The local ffmpeg pass is cloud-parity and free — prefer it (the runner
+    // downgrades to cloud if ffmpeg turns out to be unavailable at run time).
+    return "local";
+}
+// Per-knob flags, so any effect is overridable without hand-writing JSON.
+function collectDedupeEffectOverrides(values) {
+    const effects = {};
+    const numeric = [
+        ["zoom", "zoom"],
+        ["rotate", "rotate"],
+        ["skew", "skew"],
+        ["tilt", "tilt"],
+        ["speed", "speed"],
+        ["saturation", "saturation"],
+        ["contrast", "contrast"],
+        ["brightness", "brightness"],
+        ["hue", "hue_rotate"],
+        ["blur", "blur"],
+        ["noise", "noise"],
+        ["volume", "volume"]
+    ];
+    for (const [flag, key] of numeric) {
+        const raw = values[flag];
+        if (raw === undefined)
+            continue;
+        const parsed = Number(raw);
+        if (!Number.isFinite(parsed))
+            throw new Error(`--${flag} must be a number (got "${String(raw)}").`);
+        effects[key] = parsed;
+    }
+    if (values.flip)
+        effects.horizontal_flip = true;
+    if (values["effects-json"]) {
+        let parsed;
+        try {
+            parsed = JSON.parse(String(values["effects-json"]));
+        }
+        catch (error) {
+            throw new Error(`--effects-json is not valid JSON: ${error.message}`);
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("--effects-json must be a JSON object, e.g. '{\"zoom\":1.03,\"rotate\":-2}'.");
+        }
+        Object.assign(effects, parsed);
+    }
+    return effects;
+}
+async function runDedupeCommand(argv) {
+    const parsed = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            ...commonOptions(),
+            source: { type: "string" },
+            preset: { type: "string" },
+            "media-type": { type: "string" },
+            variants: { type: "string" },
+            variant: { type: "string" },
+            seed: { type: "string" },
+            "no-jitter": { type: "boolean", default: false },
+            jitter: { type: "boolean", default: false },
+            // Per-knob overrides.
+            zoom: { type: "string" },
+            rotate: { type: "string" },
+            skew: { type: "string" },
+            tilt: { type: "string" },
+            speed: { type: "string" },
+            saturation: { type: "string" },
+            contrast: { type: "string" },
+            brightness: { type: "string" },
+            hue: { type: "string" },
+            blur: { type: "string" },
+            noise: { type: "string" },
+            volume: { type: "string" },
+            flip: { type: "boolean", default: false },
+            "effects-json": { type: "string" },
+            "tint-color": { type: "string" },
+            "tint-opacity": { type: "string" },
+            width: { type: "string" },
+            height: { type: "string" },
+            crf: { type: "string" },
+            "keep-metadata": { type: "boolean", default: false },
+            "output-format": { type: "string" },
+            local: { type: "boolean", default: false },
+            cloud: { type: "boolean", default: false },
+            out: { type: "string" },
+            "out-dir": { type: "string" },
+            "no-wait": { type: "boolean", default: false },
+            tracer: { type: "string" }
+        }
+    });
+    const ctx = commonContext(parsed.values);
+    const sourceArg = parsed.values.source ?? parsed.positionals[0];
+    if (!sourceArg) {
+        throw new Error("dedupe requires a source video or image: `vidfarm dedupe <video|image|url> [--preset light|standard|strong] [--variants 3] [--out out.mp4]`.");
+    }
+    const presetRaw = parsed.values.preset?.trim().toLowerCase();
+    if (presetRaw && !isDedupePresetName(presetRaw)) {
+        throw new Error(`Unknown --preset "${presetRaw}". Choose one of: ${Object.keys(DEDUPE_PRESETS).join(", ")}.`);
+    }
+    const preset = presetRaw ?? DEDUPE_DEFAULT_PRESET;
+    const effectOverrides = collectDedupeEffectOverrides(parsed.values);
+    const variantCount = Math.max(1, Math.round(Number(parsed.values.variants ?? 1)) || 1);
+    if (variantCount > 100)
+        throw new Error("--variants is capped at 100 per run.");
+    const firstVariant = Math.max(1, Math.round(Number(parsed.values.variant ?? 1)) || 1);
+    const seed = parsed.values.seed ?? "";
+    const jitter = parsed.values["no-jitter"] ? false : (parsed.values.jitter ? true : undefined);
+    const stripMetadata = !parsed.values["keep-metadata"];
+    const mediaTypeArg = parsed.values["media-type"]?.trim().toLowerCase();
+    const mediaTypeOverride = mediaTypeArg === "image" || mediaTypeArg === "video" ? mediaTypeArg : undefined;
+    if (parsed.values.out && variantCount > 1) {
+        throw new Error("--out names a single file; with --variants use --out-dir (files are named <stem>.dedupe-NN.<ext>).");
+    }
+    let target = resolveDedupeTarget(parsed.values);
+    if (target === "local" && !(await localDedupeAvailable())) {
+        const hasCloudKey = Boolean(parsed.values["api-key"] ?? process.env.VIDFARM_API_KEY);
+        if (parsed.values.local) {
+            throw new Error("Local dedupe needs ffmpeg, which wasn't found. Install ffmpeg (or `npm i -g ffmpeg-static`), or run without --local to use the cloud primitive.");
+        }
+        if (!hasCloudKey) {
+            throw new Error("Dedupe needs either ffmpeg (for the free local pass) or a cloud API key. Install ffmpeg, or set VIDFARM_API_KEY / pass --cloud --api-key.");
+        }
+        target = "cloud";
+        if (!ctx.json)
+            console.log(`${DIM}ffmpeg not found — using the cloud dedupe primitive instead.${RESET}`);
+    }
+    if (target === "local") {
+        await runLocalDedupe(ctx, {
+            sourceArg,
+            preset,
+            effects: effectOverrides,
+            variantCount,
+            firstVariant,
+            seed,
+            jitter,
+            stripMetadata,
+            mediaType: mediaTypeOverride,
+            values: parsed.values
+        });
+        return;
+    }
+    // ---- CLOUD: billed primitive ----------------------------------------------
+    guardBilled(ctx, {
+        label: `cloud dedupe (${variantCount} variant${variantCount === 1 ? "" : "s"})`,
+        estimate: "billed at real compute ×1.2 per variant",
+        freeAlternative: "vidfarm dedupe --local (bundled ffmpeg, $0.00, identical transforms)"
+    });
+    const sourceUrl = await resolveSingleMediaUrl(ctx, sourceArg);
+    const mediaType = mediaTypeOverride
+        ?? (/\.(mp4|mov|webm|m4v|mkv)(\?|#|$)/i.test(sourceUrl) ? "video" : "image");
+    const results = [];
+    for (let index = 0; index < variantCount; index += 1) {
+        const variant = firstVariant + index;
+        const payload = {
+            source_media_url: sourceUrl,
+            media_type: mediaType,
+            engine: "ffmpeg",
+            preset,
+            variant,
+            strip_metadata: stripMetadata
+        };
+        if (Object.keys(effectOverrides).length)
+            payload.effects = effectOverrides;
+        if (seed)
+            payload.seed = seed;
+        if (jitter !== undefined)
+            payload.jitter = jitter;
+        if (parsed.values["tint-color"])
+            payload.tint_color = parsed.values["tint-color"];
+        if (parsed.values["tint-opacity"] !== undefined)
+            payload.tint_opacity = Number(parsed.values["tint-opacity"]);
+        if (parsed.values.width !== undefined)
+            payload.width = Number(parsed.values.width);
+        if (parsed.values.height !== undefined)
+            payload.height = Number(parsed.values.height);
+        if (parsed.values.crf !== undefined)
+            payload.crf = Number(parsed.values.crf);
+        if (mediaType === "image" && parsed.values["output-format"])
+            payload.output_format = parsed.values["output-format"];
+        const tracer = parsed.values.tracer
+            ? `${String(parsed.values.tracer)}-v${variant}`
+            : `devcli-dedupe-${Date.now().toString(36)}-v${variant}`;
+        const submit = await apiRequest({
+            method: "POST",
+            host: ctx.host,
+            path: "/api/v1/primitives/media/dedupe",
+            auth: ctx.auth,
+            body: { tracer, payload }
+        });
+        assertApiOk(submit, "dedupe");
+        const jobId = submit.json?.job_id;
+        if (parsed.values["no-wait"] || !jobId) {
+            if (!ctx.json && jobId)
+                console.log(`${DIM}Queued ${jobId} (variant ${variant}, tracer ${tracer}). Poll: vidfarm api GET /api/v1/user/me/jobs/${jobId}${RESET}`);
+            results.push({ variant, job_id: jobId ?? null, status: "queued" });
+            continue;
+        }
+        if (!ctx.json)
+            console.log(`${DIM}Deduplicating variant ${variant} (${jobId})… polling every 5s.${RESET}`);
+        const job = await pollGreenscreenJob(ctx, "cloud", jobId);
+        const mediaUrl = resolveJobMediaUrl(job);
+        const status = String(job?.status ?? "");
+        if (!mediaUrl) {
+            results.push({ variant, job_id: jobId, status, media_url: null });
+            if (!ctx.json)
+                console.log(`${RED}Variant ${variant} ${status || "did not finish"} — no media URL.${RESET}`);
+            process.exitCode = 1;
+            continue;
+        }
+        let outPath = null;
+        const outDir = parsed.values["out-dir"];
+        if (parsed.values.out) {
+            outPath = path.resolve(process.cwd(), String(parsed.values.out));
+        }
+        else if (outDir) {
+            const ext = mediaType === "video" ? "mp4" : String(parsed.values["output-format"] ?? "png");
+            outPath = path.resolve(process.cwd(), outDir, `dedupe-${String(variant).padStart(2, "0")}.${ext}`);
+        }
+        if (outPath)
+            await downloadUrlToFile(mediaUrl, outPath);
+        results.push({ variant, job_id: jobId, status, media_url: mediaUrl, out: outPath });
+        if (!ctx.json)
+            console.log(`${GREEN}Variant ${variant} ready:${RESET} ${mediaUrl}${outPath ? ` ${DIM}→ ${outPath}${RESET}` : ""}`);
+    }
+    if (ctx.json) {
+        printJson({ ok: true, target: "cloud", preset, media_type: mediaType, variants: results });
+    }
+    else {
+        console.log(`${DIM}Post each variant to a DIFFERENT account/slot — two accounts posting the same variant defeats the point.${RESET}`);
+    }
+}
+// Run the dedupe pass LOCALLY with bundled ffmpeg — free, offline, no wallet, no
+// in-process backend (so it works in the published cloud-only CLI). Cloud-parity
+// filter graph, straight from lib/dedupe-recipe.ts.
+async function runLocalDedupe(ctx, input) {
+    // A path on disk is used in place; anything else (url / raw id / raws path)
+    // resolves to a URL and downloads first.
+    const directPath = path.resolve(process.cwd(), input.sourceArg);
+    const isLocalFile = !/^https?:\/\//i.test(input.sourceArg) && existsSync(directPath);
+    let sourcePath = directPath;
+    let downloadDir = null;
+    if (!isLocalFile) {
+        const sourceUrl = await resolveSingleMediaUrl(ctx, input.sourceArg);
+        downloadDir = mkdtempSync(path.join(tmpdir(), "vidfarm-dedupe-dl-"));
+        sourcePath = path.join(downloadDir, path.basename(new URL(sourceUrl).pathname) || "source.bin");
+        if (!ctx.json)
+            console.log(`${DIM}Downloading source…${RESET}`);
+        await downloadUrlToFile(sourceUrl, sourcePath);
+    }
+    try {
+        const outDir = input.values["out-dir"];
+        const outputFormat = input.values["output-format"]?.trim().toLowerCase();
+        const results = [];
+        for (let index = 0; index < input.variantCount; index += 1) {
+            const variant = input.firstVariant + index;
+            let outPath;
+            if (input.values.out) {
+                outPath = path.resolve(process.cwd(), String(input.values.out));
+            }
+            else {
+                const base = defaultDedupeOutPath(sourcePath, input.variantCount > 1 ? variant : 1);
+                const named = outputFormat && /\.(png|jpe?g|webp)$/i.test(`.${outputFormat}`)
+                    ? base.replace(/\.[^.]+$/, `.${outputFormat}`)
+                    : base;
+                outPath = outDir
+                    ? path.resolve(process.cwd(), outDir, path.basename(named))
+                    : named;
+            }
+            mkdirSync(path.dirname(outPath), { recursive: true });
+            const result = await dedupeMediaLocal({
+                sourcePath,
+                outputPath: outPath,
+                mediaType: input.mediaType,
+                preset: input.preset,
+                effects: input.effects,
+                variant,
+                seed: input.seed || undefined,
+                jitter: input.jitter,
+                stripMetadata: input.stripMetadata,
+                width: input.values.width !== undefined ? Number(input.values.width) : undefined,
+                height: input.values.height !== undefined ? Number(input.values.height) : undefined,
+                tintColor: input.values["tint-color"],
+                tintOpacity: input.values["tint-opacity"] !== undefined ? Number(input.values["tint-opacity"]) : undefined,
+                crf: input.values.crf !== undefined ? Number(input.values.crf) : undefined
+            });
+            results.push(result);
+            if (!ctx.json) {
+                const label = input.variantCount > 1 ? `Variant ${variant}` : "Deduped";
+                console.log(`${GREEN}${label}:${RESET} ${result.outputPath} ${DIM}(${formatBytes(result.bytes)})${RESET}`);
+                console.log(`${DIM}  ${describeLocalDedupe(result)}${RESET}`);
+                if (result.skewDropped) {
+                    console.log(`${YELLOW}  Note:${RESET} ${DIM}this ffmpeg has no vf_perspective, so the skew stage was skipped — every other transform still applied.${RESET}`);
+                }
+            }
+        }
+        if (ctx.json) {
+            printJson({
+                ok: true,
+                target: "local",
+                preset: input.preset,
+                media_type: results[0]?.mediaType ?? null,
+                variants: results.map((result) => ({
+                    variant: result.variant,
+                    out: result.outputPath,
+                    bytes: result.bytes,
+                    effects: result.effects,
+                    effective_zoom: result.effectiveZoom,
+                    speed: result.speed,
+                    crf: result.crf,
+                    skew_applied: result.skewApplied,
+                    skew_dropped: result.skewDropped,
+                    notes: result.notes
+                }))
+            });
+        }
+        else {
+            console.log(`${DIM}Free — no wallet, no re-render. ${input.variantCount > 1 ? "Post each variant to a DIFFERENT account/slot." : "Post this instead of the original when the original has already been published."}${RESET}`);
+        }
+    }
+    finally {
+        if (downloadDir)
+            rmSync(downloadDir, { recursive: true, force: true });
+    }
+}
 // ── cutout: generate → key greenscreen → alpha-trim to min bounding box ───────
 // The one-shot "make a transparent explainer sticker" verb. Three mechanical
 // steps that used to be run by hand (generate an AI graphic on a green plate →
@@ -7687,6 +8093,28 @@ async function runPostCommand(argv) {
     assertApiOk(result, "post");
     emitResult(result, ctx.json, [["Preview post ", result.json?.post?.share_url]]);
 }
+// Destinations are otherwise invisible to an API-only caller: before this the
+// only place a channel id appeared was the Settings page in a browser.
+async function runChannelsCommand(argv) {
+    const parsed = parseArgs({ args: argv, allowPositionals: true, options: commonOptions() });
+    const ctx = commonContext(parsed.values);
+    const result = await apiRequest({ method: "GET", host: ctx.host, path: "/api/v1/user/me/channels", auth: ctx.auth });
+    assertApiOk(result, "channels");
+    emitResult(result, ctx.json);
+    if (ctx.json)
+        return;
+    const channels = (result.json?.channels ?? []);
+    console.log("");
+    if (channels.length === 0) {
+        console.log("  No destination channels connected. Add an email channel in Settings → Channels, or connect FlockPoster.");
+        return;
+    }
+    console.log(`  ${BOLD}Pass any of these to 'vidfarm schedule --to'${RESET}`);
+    for (const channel of channels) {
+        const unverified = channel.schedulable === false ? "  (unverified — confirm the emailed link first)" : "";
+        console.log(`  ${String(channel.destination_type).padEnd(12)} ${String(channel.handle || channel.title).padEnd(32)} ${channel.destination_id}${unverified}`);
+    }
+}
 async function runScheduleCommand(argv) {
     const parsed = parseArgs({
         args: argv,
@@ -7699,7 +8127,7 @@ async function runScheduleCommand(argv) {
     if (!parsed.values.at)
         throw new Error("schedule requires --at <ISO 8601 timestamp>.");
     if (!parsed.values.to)
-        throw new Error("schedule requires --to <destination_id> (a FlockPoster channel or email).");
+        throw new Error("schedule requires --to <destination> (a channel id, email address, or @handle — run 'vidfarm channels' to list them).");
     const ctx = commonContext(parsed.values);
     const result = await apiRequest({
         method: "POST",
@@ -7707,7 +8135,7 @@ async function runScheduleCommand(argv) {
         path: `/api/v1/approved/posts/${encodeURIComponent(postId)}/schedules`,
         auth: ctx.auth,
         body: {
-            destination_type: parsed.values.type,
+            destination_type: inferDestinationType(argv, parsed.values.type, parsed.values.to),
             destination_id: parsed.values.to,
             scheduled_at: parsed.values.at,
             timezone: parsed.values.timezone,
@@ -7717,6 +8145,61 @@ async function runScheduleCommand(argv) {
     assertApiOk(result, "schedule");
     emitResult(result, ctx.json);
 }
+// --type defaults to flockposter, which silently misroutes 'schedule --to
+// someone@example.com'. An address is unambiguous, so honour it unless the
+// caller said --type outright.
+function inferDestinationType(argv, type, to) {
+    if (argv.includes("--type"))
+        return type ?? "flockposter";
+    return /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(to.trim()) ? "email" : (type ?? "flockposter");
+}
+async function runRescheduleCommand(argv) {
+    const parsed = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: { ...commonOptions(), at: { type: "string" }, to: { type: "string" }, type: { type: "string", default: "flockposter" }, timezone: { type: "string" }, notes: { type: "string" } }
+    });
+    const [postId, scheduleId] = parsed.positionals;
+    if (!postId || !scheduleId)
+        throw new Error("reschedule requires <postId> <scheduleId> (list them with 'vidfarm schedules <postId>').");
+    if (!parsed.values.at)
+        throw new Error("reschedule requires --at <ISO 8601 timestamp>.");
+    if (!parsed.values.to)
+        throw new Error("reschedule requires --to <destination> (a channel id, email address, or @handle).");
+    const ctx = commonContext(parsed.values);
+    const result = await apiRequest({
+        method: "PATCH",
+        host: ctx.host,
+        path: `/api/v1/approved/posts/${encodeURIComponent(postId)}/schedules/${encodeURIComponent(scheduleId)}`,
+        auth: ctx.auth,
+        body: {
+            destination_type: inferDestinationType(argv, parsed.values.type, parsed.values.to),
+            destination_id: parsed.values.to,
+            scheduled_at: parsed.values.at,
+            timezone: parsed.values.timezone,
+            additional_notes: parsed.values.notes
+        }
+    });
+    assertApiOk(result, "reschedule");
+    emitResult(result, ctx.json);
+}
+async function runUnscheduleCommand(argv) {
+    const parsed = parseArgs({ args: argv, allowPositionals: true, options: commonOptions() });
+    const [postId, scheduleId] = parsed.positionals;
+    if (!postId || !scheduleId)
+        throw new Error("unschedule requires <postId> <scheduleId> (list them with 'vidfarm schedules <postId>').");
+    const ctx = commonContext(parsed.values);
+    const result = await apiRequest({
+        method: "DELETE",
+        host: ctx.host,
+        path: `/api/v1/approved/posts/${encodeURIComponent(postId)}/schedules/${encodeURIComponent(scheduleId)}`,
+        auth: ctx.auth
+    });
+    // A failed cancel means the send is STILL QUEUED. assertApiOk throws, which is
+    // the honest outcome — never let this print as if it cancelled.
+    assertApiOk(result, "unschedule");
+    emitResult(result, ctx.json);
+}
 async function runSchedulesCommand(argv) {
     const parsed = parseArgs({ args: argv, allowPositionals: true, options: commonOptions() });
     const postId = parsed.positionals[0];