@crievo/omni 0.0.0-stage → 0.1.1

package/tools/publish.mjs

@@ -0,0 +1,1496 @@
+#!/usr/bin/env node
+/* ============================================================================
+   Publicação: sobe o vídeo exportado no YouTube, no Instagram (Reels) e no TikTok.
+
+     node tools/publish.mjs status [--json]           as contas estão conectadas?
+     node tools/publish.mjs auth youtube              login no Google pelo navegador (uma vez)
+     node tools/publish.mjs auth tiktok               login no TikTok pelo navegador (uma vez)
+         --browser Dia                            abre em outro app em vez do navegador padrão
+         --no-open                                só imprime o link, para colar à mão
+     node tools/publish.mjs auth instagram <token>    grava o token gerado no painel da Meta
+     node tools/publish.mjs text videos/<slug> [--redo] [--json]
+         título, descrição, legenda e tags a partir do script.md (o Claude escreve;
+         sem ele, tirados do roteiro). Só preenche o que está vazio; --redo troca tudo
+     node tools/publish.mjs cover videos/<slug>       qual thumbnail vai de capa (sem publicar nada)
+     node tools/publish.mjs videos/<slug> --youtube --instagram --tiktok --confirm
+         --privacy private|unlisted|public        no YouTube (padrão: publish.youtube.privacy)
+         --tiktok-privacy SELF_ONLY|…             no TikTok (padrão: publish.tiktok.privacy)
+         --again                                  sobe outra vez onde já foi publicado
+     node tools/publish.mjs carousel videos/<slug> --confirm [--again]
+         o carrossel da pasta (carousel/export/NN.jpg, exportado na hora se faltar) no
+         Instagram, com a legenda de carousel/publication.json (ou a do carousel.json);
+         o resultado volta para carousel/publication.json
+     node tools/publish.mjs videos/<slug> --auto
+         o Claude, no fim do pipeline: nas plataformas de publish.auto, se
+         publish.auto.approved for true e o vídeo estiver pronto
+
+     node tools/publish.mjs schedule videos/<slug> --when "2026-10-14 18:00" --youtube --tiktok --confirm
+         o mesmo pedido, para o dia e a hora (hora desta máquina); aceita as
+         mesmas --privacy, --tiktok-privacy e --again
+     node tools/publish.mjs schedule videos/<slug> --reschedule --when "2026-10-15 09:30" --confirm
+         outra hora para o mesmo agendamento (plataformas, privacidade e texto ficam)
+     node tools/publish.mjs schedule videos/<slug> --cancel
+     node tools/publish.mjs scheduler [--json]                o que está agendado e se o agente está ligado
+     node tools/publish.mjs scheduler install|uninstall       o agente do launchd que confere a cada minuto
+     node tools/publish.mjs scheduler run                     publica o que venceu (o agente chama)
+     node tools/publish.mjs cloud push                        credenciais do YouTube e do TikTok e os agendamentos
+                                                              pendentes para a cloud (com cloud.schedule)
+
+   Com cloud.schedule no config, a cloud (cloud/omnichat) publica na hora: o
+   `schedule` prepara aqui o que precisa da máquina (texto, ffprobe, a capa em JPG, a regra do
+   omnichat), sobe o MP4 e a capa para a cloud e grava o pedido lá; remarcar e cancelar vão para
+   ela; o agente daqui só lê o resultado depois da hora e escreve no publication.json.
+
+   Publicar é para fora: só com pedido do usuário (o botão do studio, ou ele
+   pedindo com todas as letras, com --confirm) ou com a aprovação permanente
+   da config (--auto). Sem um dos dois, não sobe nada. Agendar é o mesmo
+   pedido, feito agora para subir depois.
+
+   O que sobe é o MP4 do export/assembly.json. Título, descrição e legenda (a
+   mesma no Instagram e no TikTok) vêm de videos/<slug>/publication.json; vazio,
+   o `text` escreve a partir do roteiro antes de subir. O rodapé de cada
+   plataforma e as hashtags de publish.text entram no fim. O resultado de
+   cada plataforma (id, link, quando, qual MP4) volta para o mesmo arquivo, e
+   é ele que impede publicar duas vezes.
+
+   A capa é a thumbnail selecionada (thumbnail/thumbnail.json `selected`), lida
+   na hora de subir: vai em JPG para o YouTube (thumbnails.set) e o Instagram
+   (cover_url). O TikTok não aceita imagem pela API. Capa que falha não derruba
+   o vídeo: fica `cover: { version, applied: false, error }` no resultado.
+
+   Credenciais no .env (fora do git): YOUTUBE_CLIENT_ID, YOUTUBE_CLIENT_SECRET,
+   YOUTUBE_REFRESH_TOKEN; INSTAGRAM_TOKEN, INSTAGRAM_USER_ID,
+   INSTAGRAM_TOKEN_EXPIRES; TIKTOK_CLIENT_KEY, TIKTOK_CLIENT_SECRET e os tokens
+   TIKTOK_* que o auth grava. Passo a passo em reference/publish.md.
+   ============================================================================ */
+
+/* The platform clients (tools/lib/platforms/), the texts and per-platform checks (tools/lib/publish/)
+   and the schedule decisions (tools/lib/schedule/) are the core; this file is the CLI: files, flags,
+   the desktop login, the local tunnel for Instagram, ffmpeg/ffprobe, `claude` and the launchd agent. */
+
+import {
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  existsSync,
+  statSync,
+  createReadStream,
+  readdirSync,
+  mkdirSync,
+  openSync,
+  writeSync,
+  closeSync,
+  unlinkSync,
+} from "node:fs";
+import { createServer } from "node:http";
+import https from "node:https";
+import { randomBytes, createHash } from "node:crypto";
+import { spawn, spawnSync } from "node:child_process";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve, dirname, basename, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  env,
+  envStore,
+  writeEnv,
+  pushInstagramToken,
+  pushPlatformEnv,
+  pullTiktokEnv,
+  cloudSettings,
+  cloudApi,
+  sleep,
+  instagramToken,
+  instagramAccount,
+  igClient,
+} from "./platforms.mjs";
+import { instagramAuthValues, publishReel, publishCarouselPost } from "./lib/platforms/instagram.mjs";
+import { askTextSync } from "./lib/agents.mjs";
+import {
+  googleClient as coreGoogleClient,
+  youtubeAccessToken,
+  youtubeAuthUrl,
+  exchangeGoogleCode,
+  youtubeChannel,
+  uploadYoutube as coreUploadYoutube,
+} from "./lib/platforms/youtube.mjs";
+import {
+  tiktokApp,
+  tiktokAccessToken,
+  fetchTiktokToken,
+  tiktokAuthUrl,
+  tiktokAccount,
+  uploadTiktok as coreUploadTiktok,
+} from "./lib/platforms/tiktok.mjs";
+import {
+  publishConfig,
+  PLATFORMS,
+  PRIVACIES,
+  TIKTOK_PRIVACIES,
+  TEXT_FIELDS,
+  withFixed as coreWithFixed,
+  instagramCaptionProblem,
+  metadata as coreMetadata,
+  defaultTitle as coreDefaultTitle,
+  textFromScript as coreTextFromScript,
+  TEXT_PROMPT,
+  parseModelText,
+  missingText,
+  platformGate,
+  publishedEntry,
+  failedEntry,
+  previousOf,
+} from "./lib/publish/publish.mjs";
+import {
+  parseWhen as coreParseWhen,
+  newSchedule,
+  reschedule,
+  dropPlatform,
+  dueAction,
+  markMissed,
+  startAttempt,
+  failureReason,
+  attemptOutcome,
+} from "./lib/schedule/schedule.mjs";
+import { CODE_ROOT, homeEnvPlist, DATA_ROOT as ROOT } from "./lib/paths.mjs";
+
+const CFG = JSON.parse(readFileSync(join(ROOT, "omnivideo.config.json"), "utf8"));
+const P = publishConfig(CFG.publish ?? {});
+
+const args = process.argv.slice(2);
+const has = n => args.includes(`--${n}`);
+const option = n => {
+  const i = args.indexOf(`--${n}`);
+  return i < 0 ? undefined : args[i + 1];
+};
+function fail(msg) {
+  console.error(`erro: ${msg}`);
+  process.exit(1);
+}
+const readJson = file => {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+};
+const log = line => console.log(line);
+const warn = line => console.error(line);
+const MB = 1024 * 1024;
+
+/* Desktop-app login (YouTube and TikTok): the platform sends the login back to a
+   server on 127.0.0.1 on a free port. The link opens in the default browser;
+   `--browser Dia` opens another app, and `--no-open` only prints the link (line
+   `url: …`) to paste in any browser on this machine: the callback goes to
+   127.0.0.1, so the login must happen here. Waits up to 10 min. */
+async function localLogin({ name, who, path = "/", buildUrl }) {
+  const state = randomBytes(16).toString("hex");
+  let redirect = "";
+  const code = await new Promise((ok, reject) => {
+    const srv = createServer((req, res) => {
+      const u = new URL(req.url, "http://127.0.0.1");
+      if (u.pathname !== path) {
+        res.writeHead(404).end();
+        return;
+      }
+      const c = u.searchParams.get("code");
+      const valid = c && u.searchParams.get("state") === state;
+      const reason =
+        u.searchParams.get("error_description") ??
+        u.searchParams.get("error") ??
+        "resposta sem code ou com state errado";
+      res
+        .writeHead(200, { "content-type": "text/html; charset=utf-8" })
+        .end(valid ? `<p>${name} conectado ao OmniVideo. Pode fechar esta aba.</p>` : `<p>Não deu: ${reason}.</p>`);
+      srv.close();
+      valid ? ok(c) : reject(new Error(`login ${who}: ${reason}`));
+    });
+    srv.listen(0, "127.0.0.1", () => {
+      redirect = `http://127.0.0.1:${srv.address().port}${path === "/" ? "" : path}`;
+      const url = buildUrl(redirect, state);
+      const app = option("browser");
+      if (has("no-open"))
+        console.log(
+          `abra o link abaixo num navegador desta máquina e escolha a conta ${who === "do Google" ? "do canal" : `do ${name}`}:`,
+        );
+      else {
+        console.log(`abrindo o login ${who} ${app ? `no ${app}` : "no navegador"}…`);
+        const p = spawnSync("open", [...(app ? ["-a", app] : []), url], { encoding: "utf8" });
+        if (p.status !== 0)
+          console.log(`não abriu${app ? ` o ${app}` : ""}: ${(p.stderr || "").trim()}. Cole o link à mão.`);
+      }
+      /* the last line with the link: the studio reads this one to show and copy it */
+      console.log(`url: ${url}`);
+    });
+    setTimeout(() => {
+      srv.close();
+      reject(new Error("10 min sem resposta do navegador"));
+    }, 600_000).unref();
+  });
+  return { code, redirect };
+}
+
+/* --- YouTube --------------------------------------------------------------------------- */
+const youtubeToken = () => youtubeAccessToken({ store: envStore });
+
+async function authYoutube() {
+  const { id, secret } = coreGoogleClient(envStore);
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  const { code, redirect } = await localLogin({
+    name: "YouTube",
+    who: "do Google",
+    buildUrl: (redirect, state) => youtubeAuthUrl({ clientId: id, redirect, state, challenge }),
+  });
+  const j = await exchangeGoogleCode({ clientId: id, secret, code, redirect, verifier });
+  if (!j.refresh_token)
+    fail(
+      "o Google não devolveu refresh_token; tire o acesso do app em myaccount.google.com/permissions e rode de novo",
+    );
+  writeEnv({ YOUTUBE_REFRESH_TOKEN: j.refresh_token });
+  await pushPlatformEnv({ YOUTUBE_REFRESH_TOKEN: j.refresh_token });
+  console.log(`YouTube conectado: ${(await youtubeChannel(j.access_token)).account}`);
+}
+
+/* The cover is the thumbnail selected in the studio (tools/thumbnail.mjs choose), read at
+   upload time: a scheduled post takes whichever is selected when the scheduler runs.
+   It goes as a JPG up to 2 MB, YouTube's limit (Instagram accepts it too). */
+const COVER_LIMIT = 2 * 1024 * 1024;
+function videoCover(dir) {
+  const t = readJson(join(dir, "thumbnail", "thumbnail.json"));
+  const png = join(dir, "thumbnail", "thumbnail.png");
+  if (!t?.selected || !existsSync(png)) return null;
+  const jpg = join(tmpdir(), `cover-${process.pid}-${randomBytes(4).toString("hex")}.jpg`);
+  for (const q of [2, 4, 6, 9, 13]) {
+    const r = spawnSync("ffmpeg", ["-y", "-loglevel", "error", "-i", png, "-q:v", String(q), jpg], {
+      encoding: "utf8",
+    });
+    if (r.status !== 0) {
+      console.error(`aviso: capa: o ffmpeg não converteu thumbnail.png: ${(r.stderr ?? "").trim().slice(-200)}`);
+      return null;
+    }
+    if (statSync(jpg).size <= COVER_LIMIT) return { version: t.selected, jpg };
+  }
+  console.error("aviso: capa: thumbnail.png não coube em 2 MB nem em JPG de qualidade baixa; sobe sem capa");
+  return null;
+}
+
+async function uploadYoutube(mp4, meta, privacy, video, cover) {
+  const token = await youtubeToken();
+  return coreUploadYoutube({
+    token,
+    bytes: readFileSync(mp4),
+    meta,
+    privacy,
+    video,
+    settings: P.youtube,
+    cover: cover ? { version: cover.version, jpeg: readFileSync(cover.jpg) } : null,
+    log,
+  });
+}
+
+/* --- Instagram (Instagram API with Instagram login) --------------------------------- */
+async function authInstagram(token) {
+  if (!token)
+    fail("passe o token: node tools/publish.mjs auth instagram <token> (reference/publish.md, Instagram passo 4)");
+  const c = await instagramAccount(token);
+  if (c.account_type && !["BUSINESS", "MEDIA_CREATOR"].includes(c.account_type)) {
+    fail(`@${c.username} é conta ${c.account_type}: a API só publica em conta profissional (Criador ou Empresa)`);
+  }
+  /* the token generated in the dashboard is already the 60-day one */
+  const values = instagramAuthValues({ token, account: c, now: Date.now() });
+  writeEnv(values);
+  await pushInstagramToken(values);
+  console.log(`Instagram conectado: @${c.username}`);
+}
+
+/* does the URL answer (206) when resolved through Cloudflare's DNS (1.1.1.1)? */
+async function reachableFromOutside(url, host) {
+  let ip;
+  try {
+    const r = await fetch(`https://1.1.1.1/dns-query?name=${host}&type=A`, {
+      headers: { accept: "application/dns-json" },
+      signal: AbortSignal.timeout(5000),
+    });
+    ip = (await r.json()).Answer?.find(a => a.type === 1)?.data;
+  } catch {
+    return false;
+  }
+  if (!ip) return false;
+  return new Promise(ok => {
+    const req = https.get(
+      url,
+      {
+        headers: { range: "bytes=0-0" },
+        lookup: (_h, opts, cb) => (opts?.all ? cb(null, [{ address: ip, family: 4 }]) : cb(null, ip, 4)),
+        timeout: 8000,
+      },
+      res => {
+        res.resume();
+        ok(res.statusCode === 206 || res.statusCode === 200);
+      },
+    );
+    req.on("timeout", () => {
+      req.destroy();
+      ok(false);
+    });
+    req.on("error", () => ok(false));
+  });
+}
+
+/* Files at a public URL for a few minutes: a server on 127.0.0.1 that only answers
+   /<token>.<ext> for each one (with Range) and a cloudflared quick tunnel in front
+   (https://<random>.trycloudflare.com). `urls` in file order; `close()` tears both down.
+   Local only: in the cloud the files are already at a public URL (object storage). */
+const TYPES = { ".mp4": "video/mp4", ".jpg": "image/jpeg" };
+async function servePublic(files) {
+  const served = new Map(
+    files.map(file => {
+      const ext = file.slice(file.lastIndexOf("."));
+      return [
+        `/${randomBytes(16).toString("hex")}${ext}`,
+        { file, size: statSync(file).size, type: TYPES[ext] ?? "application/octet-stream" },
+      ];
+    }),
+  );
+  const srv = createServer((req, res) => {
+    const s = served.get(req.url);
+    if (!s || !["GET", "HEAD"].includes(req.method)) {
+      res.writeHead(404).end();
+      return;
+    }
+    const { file, size } = s;
+    let start = 0,
+      end = size - 1,
+      code = 200;
+    const m = /^bytes=(\d*)-(\d*)$/.exec(req.headers.range ?? "");
+    if (m && (m[1] || m[2])) {
+      code = 206;
+      if (m[1]) {
+        start = +m[1];
+        if (m[2]) end = Math.min(+m[2], size - 1);
+      } else start = Math.max(0, size - +m[2]);
+      if (start > end) {
+        res.writeHead(416, { "content-range": `bytes */${size}` }).end();
+        return;
+      }
+    }
+    res.writeHead(code, {
+      "content-type": s.type,
+      "content-length": String(end - start + 1),
+      "accept-ranges": "bytes",
+      ...(code === 206 ? { "content-range": `bytes ${start}-${end}/${size}` } : {}),
+    });
+    if (req.method === "HEAD") res.end();
+    else createReadStream(file, { start, end }).pipe(res);
+  });
+  await new Promise(ok => srv.listen(0, "127.0.0.1", ok));
+  const tunnel = spawn(
+    P.instagram.cloudflared ?? "cloudflared",
+    ["tunnel", "--no-autoupdate", "--url", `http://127.0.0.1:${srv.address().port}`],
+    { stdio: ["ignore", "pipe", "pipe"] },
+  );
+  const close = () => {
+    try {
+      tunnel.kill();
+    } catch {
+      /* already exited */
+    }
+    srv.close();
+  };
+  try {
+    /* the address shows up in the output right away; the registered connection a few seconds later */
+    let output = "";
+    const waitFor = (re, label) =>
+      new Promise((ok, reject) => {
+        const check = () => {
+          const m = re.exec(output);
+          if (m) ok(m[0]);
+        };
+        tunnel.stdout.on("data", check);
+        tunnel.stderr.on("data", check);
+        check();
+        tunnel.on("error", e => reject(new Error(`cloudflared: ${e.message} (instale com brew install cloudflared)`)));
+        tunnel.on("exit", c => reject(new Error(`o cloudflared saiu com ${c}: ${output.trim().slice(-300)}`)));
+        setTimeout(() => reject(new Error(`o cloudflared não ${label} em 30 s`)), 30_000).unref();
+      });
+    tunnel.stdout.on("data", b => {
+      output += b;
+    });
+    tunnel.stderr.on("data", b => {
+      output += b;
+    });
+    const base = await waitFor(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/, "abriu o túnel");
+    await waitFor(/Registered tunnel connection/, "conectou o túnel");
+    /* The new name takes one to two minutes to answer. The proof is downloading 1 byte from
+       the public URL, with the IP taken from a public DNS: macOS's DNS caches the "does not
+       exist" of the first attempt and would delay everything. */
+    const urls = [...served.keys()].map(path => `${base}${path}`);
+    const host = new URL(base).hostname;
+    const deadline = Date.now() + 150_000;
+    for (;;) {
+      if (await reachableFromOutside(urls[0], host)) break;
+      if (Date.now() > deadline) throw new Error(`o túnel abriu, mas ${host} não respondeu em 2,5 min`);
+      await sleep(3000);
+    }
+    return { urls, close };
+  } catch (e) {
+    close();
+    throw e;
+  }
+}
+
+/* With Instagram login, Meta does not accept the file: it downloads from a public
+   video_url (resumable upload is only for apps with Facebook login). The link comes from
+   servePublic and stays up until Instagram finishes processing. The cover goes the same
+   way, as cover_url, instead of the cover_at_s frame. */
+async function uploadInstagram(mp4, caption, cover) {
+  const { token, id } = await instagramToken();
+  console.log(
+    `Instagram: abrindo um link temporário para o Instagram baixar o vídeo (${(statSync(mp4).size / 1e6).toFixed(1)} MB)…`,
+  );
+  const link = await servePublic(cover ? [mp4, cover.jpg] : [mp4]);
+  const [videoUrl, coverUrl] = link.urls;
+  return publishReel({
+    client: igClient(token),
+    userId: id,
+    videoUrl,
+    coverUrl,
+    cover,
+    caption,
+    shareToFeed: !!P.instagram.share_to_feed,
+    coverAtS: P.instagram.cover_at_s,
+    release: link.close,
+    log,
+    warn,
+  });
+}
+
+/* --- TikTok (Content Posting API, Login Kit for desktop) -------------------------------
+   The access token lasts 24 h and the refresh one year: each use renews whatever expired
+   and writes both back to .env (lib/platforms/tiktok.mjs). */
+/* with the cloud schedule, TikTok's newest tokens come down first (TikTok renews the refresh token too) */
+const tiktokToken = async () => {
+  await pullTiktokEnv();
+  return tiktokAccessToken({ store: envStore });
+};
+
+async function authTiktok() {
+  const { key } = tiktokApp(envStore);
+  /* TikTok desktop PKCE: the challenge is the SHA-256 in hex, not base64url */
+  const verifier = randomBytes(48).toString("base64url");
+  const challenge = createHash("sha256").update(verifier).digest("hex");
+  const { code, redirect } = await localLogin({
+    name: "TikTok",
+    who: "do TikTok",
+    path: "/callback/",
+    buildUrl: (redirect, state) => tiktokAuthUrl({ clientKey: key, redirect, state, challenge }),
+  });
+  const token = await fetchTiktokToken({
+    store: envStore,
+    body: { code, grant_type: "authorization_code", redirect_uri: redirect, code_verifier: verifier },
+    label: "token do TikTok",
+  });
+  console.log(`TikTok conectado: ${(await tiktokAccount(token)).account}`);
+}
+
+async function uploadTiktok(mp4, caption, video, requestedPrivacy) {
+  const token = await tiktokToken();
+  return coreUploadTiktok({
+    token,
+    bytes: readFileSync(mp4),
+    caption,
+    video,
+    requestedPrivacy,
+    settings: P.tiktok,
+    log,
+  });
+}
+
+/* --- status ------------------------------------------------------------------------------ */
+async function status() {
+  const r = {};
+  const yt = { privacy: P.youtube.privacy, audited: !!P.youtube.audited };
+  try {
+    r.youtube = { ready: true, ...(await youtubeChannel(await youtubeToken())), ...yt };
+  } catch (e) {
+    r.youtube = { ready: false, reason: e.message, ...yt };
+  }
+  try {
+    const { token } = await instagramToken();
+    const c = await instagramAccount(token);
+    r.instagram = {
+      ready: true,
+      account: `@${c.username}`,
+      username: `@${c.username}`,
+      name: c.name ?? null,
+      avatar: c.profile_picture_url ?? null,
+      expires: env("INSTAGRAM_TOKEN_EXPIRES") || null,
+    };
+  } catch (e) {
+    r.instagram = { ready: false, reason: e.message };
+  }
+  const tt = { mode: P.tiktok.mode, privacy: P.tiktok.privacy, audited: !!P.tiktok.audited };
+  try {
+    r.tiktok = {
+      ready: true,
+      ...(await tiktokAccount(await tiktokToken())),
+      expires: env("TIKTOK_REFRESH_EXPIRES") || null,
+      ...tt,
+    };
+  } catch (e) {
+    r.tiktok = { ready: false, reason: e.message, ...tt };
+  }
+  r.auto = { approved: !!P.auto.approved, platforms: P.auto.platforms };
+  r.scheduler = agentStatus();
+  if (has("json")) {
+    console.log(JSON.stringify(r));
+    return;
+  }
+  for (const name of PLATFORMS) {
+    const s = r[name];
+    console.log(`${s.ready ? "✓" : "·"} ${name}: ${s.ready ? s.account : s.reason}`);
+  }
+  console.log(
+    `  automático: ${P.auto.approved ? `ligado (${P.auto.platforms.join(", ")})` : "desligado (publish.auto.approved)"}`,
+  );
+  console.log(
+    `  agenda: ${r.scheduler.loaded ? "agente ligado, confere a cada minuto" : "agente desligado (node tools/publish.mjs scheduler install)"}`,
+  );
+  if (r.youtube.ready && !P.youtube.audited)
+    console.log(
+      "  YouTube: projeto sem auditoria, o vídeo fica privado até você abrir no Studio (publish.youtube.audited)",
+    );
+  if (r.instagram.expires)
+    console.log(
+      `  Instagram: token vale até ${new Date(r.instagram.expires).toLocaleDateString("pt-BR")} (renova sozinho a cada publicação)`,
+    );
+  if (r.tiktok.ready && P.tiktok.mode === "draft")
+    console.log("  TikTok: modo rascunho, o vídeo vai para a caixa de entrada do app e você termina a postagem lá");
+  else if (r.tiktok.ready && !P.tiktok.audited)
+    console.log('  TikTok: app sem auditoria, o vídeo sobe como "só eu" (publish.tiktok.audited)');
+}
+
+/* --- text from the script ------------------------------------------------------------- */
+function readScript(dir) {
+  try {
+    return readFileSync(join(dir, "script.md"), "utf8");
+  } catch {
+    return "";
+  }
+}
+
+const defaultTitle = dir =>
+  coreDefaultTitle({
+    scenesTitle: readJson(join(dir, "scenes.json"))?.title,
+    script: readScript(dir),
+    dirName: dir.split("/").pop(),
+  });
+
+/* without Claude: the script's title, the thesis as description and the hook (first line) as caption */
+const textFromScript = dir => coreTextFromScript(readScript(dir), defaultTitle(dir));
+
+/* one short answer with the script on stdin, on the agent accounts in rotation (tools/lib/agents.mjs):
+   one that hits its limit is set aside and the next answers; ~/.claude is never used */
+function textFromClaude(dir) {
+  const script = readScript(dir);
+  if (!script.trim()) throw new Error("sem script.md");
+  const { text } = askTextSync(
+    {
+      root: ROOT,
+      cfg: CFG,
+      prompt: TEXT_PROMPT,
+      claudeModel: CFG.publish?.text?.model ?? CFG.models?.orchestrator?.model ?? "sonnet",
+      tmpDir: tmpdir(),
+    },
+    (bin, args, env) =>
+      spawnSync(bin, args, { cwd: ROOT, input: script, encoding: "utf8", env, timeout: 180_000, maxBuffer: 4 * MB }),
+  );
+  return parseModelText(text);
+}
+
+/* fills what is empty in publication.json (everything, with redo) and writes it */
+function writeText(dir, redo) {
+  const file = join(dir, "publication.json");
+  const pub = readJson(file) ?? {};
+  const missing = missingText(pub, redo);
+  if (!missing.length) return { pub, by: null, warning: null };
+  let fresh,
+    by = "claude",
+    warning = null;
+  try {
+    fresh = textFromClaude(dir);
+  } catch (e) {
+    fresh = textFromScript(dir);
+    by = "script";
+    warning = `o agente não escreveu o texto (${e.message}); usei o título, a tese e o gancho do roteiro`;
+  }
+  for (const k of missing) pub[k] = fresh[k];
+  pub.text_generated = { at: new Date().toISOString(), by };
+  writePub(file, pub);
+  return { pub, by, warning };
+}
+
+function text(dir) {
+  const { pub, by, warning } = writeText(dir, has("redo"));
+  if (warning) console.error(`aviso: ${warning}`);
+  const data = Object.fromEntries(TEXT_FIELDS.map(k => [k, pub[k] ?? (k === "tags" ? [] : "")]));
+  if (has("json")) {
+    console.log(JSON.stringify({ ...data, by, warning }));
+    return;
+  }
+  if (!by) console.log("o texto já estava escrito (--redo troca)");
+  for (const k of TEXT_FIELDS) console.log(`${k}: ${Array.isArray(data[k]) ? data[k].join(", ") : data[k]}`);
+}
+
+/* --- publish one video ----------------------------------------------------------------------- */
+function exported(dir) {
+  const m = readJson(join(dir, "export", "assembly.json"));
+  if (!m?.mp4) fail("sem export/assembly.json: monte o vídeo antes (node tools/assemble.mjs)");
+  const mp4 = join(dir, m.mp4);
+  if (!existsSync(mp4)) fail(`${m.mp4} não existe: monte o vídeo de novo`);
+  return { mp4, rel: m.mp4, mtime: Math.round(statSync(mp4).mtimeMs), w: m.w, h: m.h, duration: m.duration };
+}
+
+/* the footer and the fixed hashtags of publish.text go at the end, without repeating what the text has */
+const withFixed = (text, footer) => coreWithFixed(text, footer, P.text.hashtags);
+
+/* each platform's limits, checked before uploading anything */
+const metadata = (dir, pub) => coreMetadata({ pub, defaultTitle: () => defaultTitle(dir), text: P.text });
+
+/* only a change is written: every write is a studio notice (video, omnichat, analytics), and the
+   scheduler rereads the cloud every minute while a job runs */
+function writePub(file, pub) {
+  const text = JSON.stringify(pub, null, 2) + "\n";
+  try {
+    if (readFileSync(file, "utf8") === text) return;
+  } catch {
+    /* no file yet */
+  }
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, text);
+  renameSync(tmp, file);
+}
+
+/* --auto only publishes a video that finished the pipeline: every stage ✓, export up to date,
+   and an assembly without warnings */
+function checkAuto(dir) {
+  if (!P.auto.approved) fail("publish.auto.approved está false: publicar só com pedido do usuário (--confirm)");
+  for (const n of [...PLATFORMS, "privacy", "tiktok-privacy", "again", "confirm"]) {
+    if (has(n)) fail(`--auto usa as plataformas e a privacidade da config; não combina com --${n}`);
+  }
+  const py =
+    [join(CODE_ROOT, ".venv", "bin", "python"), CFG.voicestudio?.python ?? ""].find(p => p && existsSync(p)) ??
+    "python3";
+  const r = spawnSync(py, [join(CODE_ROOT, "tools", "omnivideo.py"), "status", dir, "--json"], { encoding: "utf8" });
+  if (r.status !== 0) fail(`status do vídeo: ${(r.stderr || r.stdout).slice(-400)}`);
+  const st = JSON.parse(r.stdout);
+  const stage = id => st.stages?.find(e => e.id === id);
+  const problems = [];
+  if (!st.ready) problems.push(`o vídeo não terminou o pipeline (próxima: ${st.next?.name ?? "?"})`);
+  if (stage("export")?.outdated)
+    problems.push("o export está desatualizado: cenas, voz ou legenda mudaram depois da montagem");
+  const m = readJson(join(dir, "export", "assembly.json"));
+  if (m?.warnings?.length) problems.push(`a montagem deixou avisos: ${m.warnings.join("; ")}`);
+  if (problems.length) fail("publicação automática recusada:\n  " + problems.join("\n  "));
+}
+
+/* where and how: the request's flags (or the config, with --auto) */
+function publishRequest(auto) {
+  const platforms = PLATFORMS.filter(p => (auto ? P.auto.platforms.includes(p) : has(p)));
+  if (!platforms.length)
+    fail(auto ? "publish.auto.platforms está vazio" : "diga onde: --youtube, --instagram, --tiktok (uma ou mais)");
+  const privacy = (auto ? null : option("privacy")) ?? P.youtube.privacy;
+  if (!PRIVACIES.includes(privacy)) fail(`privacidade: ${PRIVACIES.join(", ")}`);
+  const tiktokPrivacy = (auto ? null : option("tiktok-privacy")) ?? P.tiktok.privacy;
+  if (!TIKTOK_PRIVACIES.includes(tiktokPrivacy)) fail(`privacidade do TikTok: ${TIKTOK_PRIVACIES.join(", ")}`);
+  return { platforms, privacy, tiktokPrivacy };
+}
+
+/* without a title, the text comes from the script before uploading */
+function ensureText(dir) {
+  if (String(readJson(join(dir, "publication.json"))?.title ?? "").trim()) return;
+  const { by, warning } = writeText(dir, false);
+  if (warning) console.error(`aviso: ${warning}`);
+  if (by)
+    console.log(
+      `texto escrito a partir do roteiro (${by === "claude" ? "pelo Claude" : "tirado do roteiro"}): publication.json`,
+    );
+}
+
+const FROM_SCHEDULER = process.env.OMNIVIDEO_ORIGIN === "schedule";
+
+/* The Reel is live: the video's omnichat replies on it. `omnichat.mjs published` says whether
+   the rule was already enabled and, with omnichat.instagram.enable_on_publish, enables the
+   missing one (no rule: from the narration's "comenta X que eu te mando"). Nothing from it
+   brings down the publication. */
+function omnichatOnPublish(dir) {
+  const r = spawnSync(process.execPath, [join(CODE_ROOT, "tools", "omnichat.mjs"), "published", dir], {
+    encoding: "utf8",
+    timeout: 60_000,
+  });
+  const output = [r.stdout, r.stderr]
+    .map(s => (s ?? "").trim())
+    .filter(Boolean)
+    .join("\n");
+  if (r.status === 0) {
+    if (output) console.log(output);
+  } else
+    console.error(
+      `aviso: omnichat: o Reel subiu, mas a regra não foi conferida: ${output.replace(/^erro: /, "") || r.error?.message || `saiu com ${r.status}`}`,
+    );
+}
+
+const longDate = iso => new Date(iso).toLocaleString("pt-BR");
+
+/* the uploaded MP4 as the platforms see it: ffprobe, or assembly.json when it fails */
+function probeVideo(exp) {
+  const probeRun = spawnSync(
+    "ffprobe",
+    [
+      "-v",
+      "error",
+      "-select_streams",
+      "v:0",
+      "-show_entries",
+      "stream=width,height:format=duration",
+      "-of",
+      "json",
+      exp.mp4,
+    ],
+    { encoding: "utf8" },
+  );
+  const probe = probeRun.status === 0 ? JSON.parse(probeRun.stdout) : null;
+  return {
+    w: probe?.streams?.[0]?.width ?? exp.w,
+    h: probe?.streams?.[0]?.height ?? exp.h,
+    duration: +(probe?.format?.duration ?? exp.duration),
+  };
+}
+
+async function publish(dir) {
+  const auto = has("auto");
+  if (auto) checkAuto(dir);
+  else if (!has("confirm"))
+    fail("publicar é para fora: só com pedido do usuário (--confirm) ou com publish.auto.approved (--auto)");
+  const { platforms, privacy, tiktokPrivacy } = publishRequest(auto);
+
+  const file = join(dir, "publication.json");
+  const sch = readJson(file)?.schedule;
+  if (!FROM_SCHEDULER && sch?.state === "publishing" && alive(sch.pid))
+    fail("a agenda está publicando este vídeo agora: espere terminar");
+  ensureText(dir);
+  const pub = readJson(file) ?? {};
+  const exp = exported(dir);
+  const meta = metadata(dir, pub);
+  if (meta.problems.length) fail("não dá para publicar:\n  " + meta.problems.join("\n  "));
+  const video = probeVideo(exp);
+
+  const cover = platforms.some(p => p !== "tiktok") ? videoCover(dir) : null;
+  if (cover) console.log(`capa: thumbnail ${cover.version} (YouTube e Instagram)`);
+  if (cover && platforms.includes("tiktok"))
+    console.log("aviso: tiktok: a API não aceita capa própria; vai o quadro de publish.tiktok.cover_at_s");
+
+  let failed = false;
+  for (const plat of platforms) {
+    const before = pub[plat];
+    const gate = platformGate({ platform: plat, before, video, again: has("again"), format: longDate });
+    if (gate.action === "skip") {
+      console.log(gate.message);
+      continue;
+    }
+    for (const w of gate.warnings) console.log(w);
+    if (gate.action === "refuse") {
+      console.error(gate.message);
+      failed = true;
+      continue;
+    }
+    try {
+      const r =
+        plat === "youtube"
+          ? await uploadYoutube(exp.mp4, meta, privacy, video, cover)
+          : plat === "instagram"
+            ? await uploadInstagram(exp.mp4, meta.caption, cover)
+            : await uploadTiktok(exp.mp4, meta.tiktokCaption, video, tiktokPrivacy);
+      pub[plat] = publishedEntry({
+        result: r,
+        before,
+        mp4: exp.rel,
+        mp4Mtime: exp.mtime,
+        scheduledFor: FROM_SCHEDULER ? process.env.OMNIVIDEO_SCHEDULED_FOR : null,
+        now: Date.now(),
+      });
+      /* published by hand where it was scheduled: the scheduler does not upload it again */
+      if (!FROM_SCHEDULER && dropPlatform(pub, plat)) console.log(`${plat}: saiu da agenda (publicado agora)`);
+      writePub(file, pub);
+      console.log(
+        `${plat}: ${r.draft ? "enviado para a caixa de entrada do app (termine a postagem no TikTok)" : `publicado → ${r.url ?? r.id}`}`,
+      );
+      if (r.cover?.applied) console.log(`  capa ${r.cover.version} aplicada`);
+      else if (r.cover)
+        console.log(
+          `aviso: ${plat}: o vídeo subiu, mas a capa ${r.cover.version} não foi: ${r.cover.error}${r.studio ? `. Troque no Studio: ${r.studio}` : ""}`,
+        );
+      if (plat === "youtube" && r.privacy !== "private" && !P.youtube.audited) {
+        console.log(
+          `  o projeto do Google ainda não passou pela auditoria: o YouTube trava o vídeo como privado. Mude no Studio: ${r.studio}`,
+        );
+      }
+      if (plat === "instagram") omnichatOnPublish(dir);
+    } catch (e) {
+      console.error(`${plat}: ${e.message}`);
+      pub[plat] = failedEntry(before, e.message, Date.now());
+      writePub(file, pub);
+      failed = true;
+    }
+  }
+  if (cover)
+    try {
+      unlinkSync(cover.jpg);
+    } catch {
+      /* already gone */
+    }
+  if (failed) process.exit(1);
+}
+
+/* --- carousel -------------------------------------------------------------------------------
+   Instagram only. With Instagram login, images do not go up as files either: each JPEG goes
+   through a public image_url (the same servePublic as the Reel), becomes a child container
+   (is_carousel_item), and the CAROUSEL container joins the children with the caption. The
+   caption is carousel/publication.json's (the studio writes the edited text there) or
+   carousel.json's, with publish.text's footer and hashtags. The result goes back to
+   carousel/publication.json. */
+async function publishCarousel(videoDir) {
+  if (!has("confirm")) fail("publicar é para fora: só com pedido do usuário (--confirm)");
+  const { diagnosisOf, exportOf, LIMITS } = await import("./carousel.mjs");
+  const dir = join(videoDir, "carousel");
+  let d = diagnosisOf(videoDir);
+  if (!d.exists) fail("a pasta não tem carousel/carousel.json");
+  const comp = d.stages.find(e => e.id === "composition");
+  if (!comp?.ok) fail(`a composição do carrossel não está pronta: ${comp?.missing ?? "rode o build"}`);
+  if (!d.stages.find(e => e.id === "export")?.ok) {
+    exportOf(videoDir);
+    d = diagnosisOf(videoDir);
+  }
+  const exp = readJson(join(dir, "export", "export.json"));
+  const jpgs = (exp?.slides ?? []).map(s => join(dir, s.jpg));
+  if (jpgs.length < 2) fail("o carrossel precisa de pelo menos 2 slides");
+  if (jpgs.length > LIMITS.publish)
+    fail(`${jpgs.length} slides: a publicação aceita até ${LIMITS.publish} (carousel.slides.publish)`);
+  if (jpgs.some(j => !existsSync(j))) fail("faltam JPEG em carousel/export: exporte de novo");
+  /* the API accepts images from 4:5 to 1.91:1 (the app's 3:4 does not go through it yet) */
+  const f = exp.format ?? {};
+  if (f.w && f.h && f.w / f.h < 0.8 - 1e-3)
+    fail(`formato ${f.ratio ?? `${f.w}×${f.h}`}: a API do Instagram aceita imagem de 4:5 a 1,91:1`);
+
+  const file = join(dir, "publication.json");
+  const pub = readJson(file) ?? {};
+  if (pub.instagram?.id && !has("again")) {
+    console.log(
+      `instagram: já publicado em ${longDate(pub.instagram.published_at)}: ${pub.instagram.url ?? pub.instagram.id} (--again sobe outra vez)`,
+    );
+    return;
+  }
+  const text = String(pub.caption ?? readJson(join(dir, "carousel.json"))?.caption ?? "").trim();
+  if (!text)
+    fail("o carrossel não tem legenda: escreva na etapa Publicar do carrossel (ou em caption no carousel.json)");
+  const caption = withFixed(text, P.text.footer_instagram);
+  const captionProblem = instagramCaptionProblem(caption);
+  if (captionProblem) fail(captionProblem);
+
+  try {
+    const { token, id } = await instagramToken();
+    console.log(`Instagram: abrindo um link temporário para o Instagram baixar os ${jpgs.length} slides…`);
+    const link = await servePublic(jpgs);
+    const done = await publishCarouselPost({
+      client: igClient(token),
+      userId: id,
+      imageUrls: link.urls,
+      caption,
+      release: link.close,
+      log,
+    });
+    const previous = previousOf(pub.instagram);
+    pub.instagram = {
+      id: done.id,
+      url: done.url,
+      type: "CAROUSEL_ALBUM",
+      slides: jpgs.length,
+      published_at: new Date().toISOString(),
+      export: exp.exported_at,
+      ...(previous?.length ? { previous } : {}),
+    };
+    writePub(file, pub);
+    console.log(`instagram: carrossel publicado → ${done.url ?? done.id}`);
+    omnichatOnPublish(dir);
+  } catch (e) {
+    pub.instagram = failedEntry(pub.instagram, e.message, Date.now());
+    writePub(file, pub);
+    throw e;
+  }
+}
+
+/* --- schedule -------------------------------------------------------------------------------
+   Scheduling is the --confirm request made now to upload later: the day, the time and the
+   platforms live in publication.json (`schedule`). The uploader is `scheduler run`, which
+   the launchd agent (`scheduler install`) calls every minute, with the studio open or not:
+   each due video goes up through a child publish.mjs with --confirm, same as the button.
+   The due / missed / retry decisions are lib/schedule/schedule.mjs.
+
+   The agent does not wake the Mac. Asleep or off at the time, the video goes up when it
+   comes back, up to publish.schedule.max_delay_h later; past that, it is "missed" and does
+   not go up. A failure on one platform retries only there (publish.schedule.attempts,
+   every interval_min) and then stays "failed", waiting for you. */
+/* own dir: the queue reads every .json in .queue/ as a ticket */
+const SCHEDULE_DIR = join(ROOT, ".schedule");
+const INDEX_FILE = join(SCHEDULE_DIR, "dirs.json"); /* videos outside videos/ that were scheduled */
+const LOCK_FILE = join(SCHEDULE_DIR, "running.lock");
+const LOG_FILE = join(SCHEDULE_DIR, "schedule.log");
+const AGENT = "com.omnivideo.schedule";
+const PLIST = join(homedir(), "Library", "LaunchAgents", `${AGENT}.plist`);
+const SELF = fileURLToPath(import.meta.url);
+
+const alive = pid => {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+};
+const dayTime = iso =>
+  new Date(iso).toLocaleString("pt-BR", {
+    weekday: "short",
+    day: "2-digit",
+    month: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+const nowIso = () => new Date().toISOString();
+
+/* "2026-10-14 18:00" or "2026-10-14T18:00" is this machine's time; with Z or an offset, the text's */
+function parseWhen(s) {
+  try {
+    return coreParseWhen(s, { now: Date.now(), format: dayTime });
+  } catch (e) {
+    fail(e.message);
+  }
+}
+
+async function schedule(dir) {
+  const file = join(dir, "publication.json");
+  const current = readJson(file)?.schedule;
+  if (current?.state === "publishing" && alive(current.pid)) fail("a publicação agendada já começou: espere terminar");
+  if (has("cancel")) {
+    const pub = readJson(file) ?? {};
+    if (!pub.schedule) {
+      console.log("não havia agendamento");
+      return;
+    }
+    if (pub.schedule.cloud) await cloudApi("DELETE", `/api/schedule/${basename(dir)}`);
+    delete pub.schedule;
+    writePub(file, pub);
+    console.log("agendamento cancelado");
+    return;
+  }
+  if (!has("confirm")) fail("agendar é publicar para fora, só que depois: só com pedido do usuário (--confirm)");
+  const when = parseWhen(option("when"));
+  /* another time for the same request (the studio calendar, dragging): platforms,
+     privacy and text stay; the attempt count restarts */
+  if (has("reschedule")) {
+    const pub = readJson(file) ?? {};
+    if (!pub.schedule) fail("este vídeo não tem publicação agendada para remarcar");
+    const before = pub.schedule.when;
+    if (pub.schedule.cloud) {
+      const r = await cloudApi("POST", `/api/schedule/${basename(dir)}/reschedule`, { when: when.toISOString() });
+      if (!r.ok) fail("a cloud não achou este agendamento ativo: agende de novo");
+    }
+    pub.schedule = { ...reschedule(pub.schedule, when, Date.now()), ...(pub.schedule.cloud ? { cloud: true } : {}) };
+    writePub(file, pub);
+    console.log(`remarcado: de ${dayTime(before)} para ${dayTime(when)}`);
+    return;
+  }
+  const { platforms, privacy, tiktokPrivacy } = publishRequest(false);
+  exported(dir);
+  /* the text is written and checked now, so you see what will go up */
+  ensureText(dir);
+  const pub = readJson(file) ?? {};
+  const meta = metadata(dir, pub);
+  if (meta.problems.length) fail("não dá para agendar:\n  " + meta.problems.join("\n  "));
+  const already = platforms.filter(p => pub[p]?.id);
+  if (already.length && !has("again")) fail(`já publicado em ${already.join(", ")}: --again para subir outra vez`);
+
+  pub.schedule = newSchedule({
+    when,
+    platforms,
+    privacy,
+    tiktokPrivacy,
+    republish: has("again"),
+    now: Date.now(),
+    origin: process.env.OMNIVIDEO_ORIGIN ?? "terminal",
+  });
+  writePub(file, pub);
+  if (cloudSchedules()) {
+    try {
+      await scheduleToCloud(dir);
+    } catch (e) {
+      const back = readJson(file) ?? {};
+      delete back.schedule;
+      writePub(file, back);
+      fail(`a cloud não recebeu o agendamento (nada ficou agendado): ${e.message}`);
+    }
+    console.log(`agendado na cloud: ${platforms.join(", ")} em ${dayTime(when)}`);
+    return;
+  }
+  if (!dir.startsWith(join(ROOT, "videos") + sep)) {
+    mkdirSync(SCHEDULE_DIR, { recursive: true });
+    const index = new Set(readJson(INDEX_FILE) ?? []);
+    index.add(dir);
+    writeFileSync(INDEX_FILE, JSON.stringify([...index], null, 2) + "\n");
+  }
+  console.log(`agendado: ${platforms.join(", ")} em ${dayTime(when)}`);
+  if (!agentStatus().loaded)
+    console.log(
+      "aviso: o agente da agenda está desligado e nada sobe na hora: node tools/publish.mjs scheduler install",
+    );
+}
+
+/* --- the cloud schedule (cloud.schedule) ------------------------------------------------------
+   What needs this machine is done when scheduling: the text, ffprobe, the cover JPEG and the omnichat
+   rule the Reel will have. The MP4 and the cover go to the cloud's storage, and the job carries the
+   rest; the cloud publishes at the time and keeps each platform's entry, which `scheduler run` (the
+   agent) reads after the time and writes here. */
+const cloudSchedules = () => cloudSettings().owns.schedule;
+
+async function cloudUpload(slug, name, file) {
+  const c = cloudSettings();
+  const r = await fetch(`${c.url}/api/schedule/${slug}/files/${name}`, {
+    method: "PUT",
+    headers: { authorization: `Bearer ${env("OMNICHAT_CLOUD_SECRET")}` },
+    body: readFileSync(file),
+  });
+  const j = await r.json().catch(() => ({}));
+  if (!r.ok || !j.key) throw new Error(`subir ${name}: ${r.status} ${j.error ?? ""}`.trim());
+  return j.key;
+}
+
+/* the rule the Reel will have, from `omnichat.mjs published --plan` (null: none goes live) */
+function omnichatPlan(dir) {
+  const r = spawnSync(process.execPath, [join(CODE_ROOT, "tools", "omnichat.mjs"), "published", dir, "--plan"], {
+    encoding: "utf8",
+    timeout: 60_000,
+  });
+  try {
+    return JSON.parse(r.stdout.trim().split("\n").pop() ?? "null");
+  } catch {
+    return null;
+  }
+}
+
+async function scheduleToCloud(dir) {
+  const file = join(dir, "publication.json");
+  const pub = readJson(file) ?? {};
+  const sch = pub.schedule;
+  const exp = exported(dir);
+  const meta = metadata(dir, pub);
+  const video = probeVideo(exp);
+  const cover = sch.platforms.some(p => p !== "tiktok") ? videoCover(dir) : null;
+  const slug = basename(dir);
+  console.log(`subindo o vídeo para a cloud (${(statSync(exp.mp4).size / 1e6).toFixed(1)} MB)…`);
+  try {
+    const media = { video: await cloudUpload(slug, "video.mp4", exp.mp4), cover: null };
+    if (cover) media.cover = await cloudUpload(slug, "cover.jpg", cover.jpg);
+    const plan = sch.platforms.includes("instagram") ? omnichatPlan(dir) : null;
+    await cloudApi("PUT", `/api/schedule/${slug}`, {
+      job: {
+        when: sch.when,
+        platforms: sch.platforms,
+        privacy: sch.privacy,
+        tiktok_privacy: sch.tiktok_privacy,
+        republish: !!sch.republish,
+        meta,
+        video,
+        cover: cover ? { version: cover.version } : null,
+        media,
+        mp4: { rel: exp.rel, mtime: exp.mtime },
+        before: Object.fromEntries(sch.platforms.map(p => [p, pub[p] ?? null])),
+        settings: {
+          youtube: P.youtube,
+          tiktok: P.tiktok,
+          instagram: { share_to_feed: !!P.instagram.share_to_feed, cover_at_s: P.instagram.cover_at_s ?? null },
+          schedule: P.schedule,
+        },
+        omnichat: plan?.rule ? { rule: plan.rule } : null,
+      },
+    });
+  } finally {
+    if (cover)
+      try {
+        unlinkSync(cover.jpg);
+      } catch {
+        /* already gone */
+      }
+  }
+  const now = readJson(file) ?? {};
+  now.schedule = { ...now.schedule, cloud: true };
+  writePub(file, now);
+}
+
+/* After the time: the cloud's outcome into publication.json, as a local run would write it */
+async function syncFromCloud(dir) {
+  const file = join(dir, "publication.json");
+  const pub = readJson(file) ?? {};
+  const sch = pub.schedule;
+  const name = basename(dir);
+  let j;
+  try {
+    j = await cloudApi("GET", `/api/schedule/${name}`);
+  } catch (e) {
+    console.log(`${nowIso()} ${name}: não deu para ler a cloud: ${e.message}`);
+    return;
+  }
+  const steps = j.steps ?? {};
+  for (const p of sch.platforms) if (steps[p]?.entry) pub[p] = steps[p].entry;
+  const igLive = steps.instagram?.state === "done" && !sch.synced_instagram;
+  if (j.state === "done") {
+    delete pub.schedule;
+    console.log(`${nowIso()} ${name}: publicado pela cloud`);
+  } else if (j.state === "failed" || j.state === "canceled" || j.state === "missed") {
+    const missing = sch.platforms.filter(p => steps[p]?.state !== "done");
+    pub.schedule = {
+      ...sch,
+      platforms: missing,
+      state: j.state === "canceled" ? "failed" : j.state,
+      last_error: j.last_error ?? null,
+    };
+    console.log(`${nowIso()} ${name}: a cloud não publicou ${missing.join(", ")}: ${j.last_error?.message ?? j.state}`);
+  } else {
+    pub.schedule = {
+      ...sch,
+      state: "publishing",
+      last_error: j.last_error ?? null,
+      ...(igLive ? { synced_instagram: true } : {}),
+    };
+  }
+  writePub(file, pub);
+  /* the Reel went up: the local rule matches the one the cloud turned on (and goes up again, the same) */
+  if (igLive) omnichatOnPublish(dir);
+}
+
+/* cloud push: the credentials, the switch, and what was scheduled here before the switch */
+async function cloudPush() {
+  if (!cloudSettings().ready) fail("cloud não configurada: cloud.url no config e OMNICHAT_CLOUD_SECRET no .env");
+  const keys = [
+    "YOUTUBE_CLIENT_ID",
+    "YOUTUBE_CLIENT_SECRET",
+    "YOUTUBE_REFRESH_TOKEN",
+    "TIKTOK_CLIENT_KEY",
+    "TIKTOK_CLIENT_SECRET",
+    "TIKTOK_ACCESS_TOKEN",
+    "TIKTOK_ACCESS_EXPIRES",
+    "TIKTOK_REFRESH_TOKEN",
+    "TIKTOK_REFRESH_EXPIRES",
+    "TIKTOK_OPEN_ID",
+    "TIKTOK_SCOPES",
+  ];
+  const values = Object.fromEntries(keys.map(k => [k, env(k)]).filter(([, v]) => v));
+  await cloudApi("PUT", "/api/platform-env", { values });
+  const { token, id } = await instagramToken();
+  await cloudApi("PUT", "/api/account", { id, token, expires: env("INSTAGRAM_TOKEN_EXPIRES") || null });
+  await cloudApi("PUT", "/api/schedule/active", { active: cloudSchedules() });
+  console.log(`credenciais na cloud: ${Object.keys(values).length ? Object.keys(values).join(", ") : "nenhuma"}`);
+  if (!cloudSchedules()) {
+    console.log("a cloud recebeu, mas quem publica a agenda ainda é esta máquina (cloud.schedule: true para virar)");
+    return;
+  }
+  for (const { dir, sch } of scheduled()) {
+    if (sch.cloud || sch.state !== "scheduled") continue;
+    await scheduleToCloud(dir);
+    console.log(`  ${basename(dir)}: agendamento de ${dayTime(sch.when)} foi para a cloud`);
+  }
+  console.log("a cloud publica a agenda a partir de agora (cloud.schedule)");
+}
+
+function scheduled() {
+  const base = join(ROOT, "videos");
+  let names = [];
+  try {
+    names = readdirSync(base);
+  } catch {
+    /* no videos/ */
+  }
+  const dirs = new Set([...names.map(n => join(base, n)), ...(readJson(INDEX_FILE) ?? [])]);
+  return [...dirs]
+    .map(dir => ({ dir, sch: readJson(join(dir, "publication.json"))?.schedule }))
+    .filter(x => x.sch)
+    .sort((a, b) => a.sch.when.localeCompare(b.sch.when));
+}
+
+function listSchedule() {
+  const items = scheduled().map(({ dir, sch }) => ({ slug: basename(dir), dir, ...sch }));
+  const agent = agentStatus();
+  if (has("json")) {
+    console.log(JSON.stringify({ agent, items }));
+    return;
+  }
+  console.log(
+    `agente: ${agent.loaded ? "ligado, confere a cada minuto" : "desligado (scheduler install)"}${agent.installed && !agent.node_ok ? " · o node do agente sumiu: rode scheduler install de novo" : ""}`,
+  );
+  if (!items.length) console.log("nada agendado");
+  for (const i of items) {
+    const error = i.last_error ? ` · ${i.last_error.message}` : "";
+    console.log(`${dayTime(i.when)}  ${i.state.padEnd(10)} ${i.platforms.join(", ").padEnd(26)} ${i.slug}${error}`);
+  }
+}
+
+/* one `scheduler run` at a time: the every-minute agent and someone in the terminal don't upload the same video twice */
+function lock() {
+  mkdirSync(SCHEDULE_DIR, { recursive: true });
+  for (let i = 0; i < 2; i++) {
+    try {
+      const fd = openSync(LOCK_FILE, "wx");
+      writeSync(fd, String(process.pid));
+      closeSync(fd);
+      return () => {
+        try {
+          unlinkSync(LOCK_FILE);
+        } catch {
+          /* already gone */
+        }
+      };
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+      if (alive(+readFileSync(LOCK_FILE, "utf8"))) return null;
+      try {
+        unlinkSync(LOCK_FILE);
+      } catch {
+        /* someone else took it */
+      }
+    }
+  }
+  return null;
+}
+
+async function runScheduler() {
+  const release = lock();
+  if (!release) return;
+  try {
+    for (const { dir, sch } of scheduled()) {
+      if (cloudSchedules()) {
+        /* the cloud publishes: here only its outcome is read, and only after the time */
+        if (sch.cloud && ["scheduled", "publishing"].includes(sch.state) && Date.parse(sch.when) <= Date.now())
+          await syncFromCloud(dir);
+        else if (!sch.cloud && sch.state === "scheduled")
+          console.log(`${nowIso()} ${basename(dir)}: agendado antes da cloud: node tools/publish.mjs cloud push`);
+        continue;
+      }
+      if (sch.cloud) continue;
+      runOne(dir);
+    }
+  } finally {
+    release();
+  }
+}
+
+function runOne(dir) {
+  const file = join(dir, "publication.json");
+  const pub = readJson(file);
+  const sch = pub?.schedule;
+  const name = basename(dir);
+  const due = dueAction(sch, { now: Date.now(), alive, settings: P.schedule });
+  if (due.action === "skip") return;
+  if (due.action === "missed") {
+    markMissed(sch, due.message, Date.now());
+    writePub(file, pub);
+    console.log(`${nowIso()} ${name}: perdido, ${sch.last_error.message}`);
+    return;
+  }
+
+  const startedAt = nowIso();
+  startAttempt(sch, { pid: process.pid, startedAt });
+  writePub(file, pub);
+  console.log(
+    `${startedAt} ${name}: publicando ${sch.platforms.join(", ")} (agendado para ${dayTime(sch.when)}, tentativa ${sch.attempts})`,
+  );
+  const r = spawnSync(
+    process.execPath,
+    [
+      SELF,
+      dir,
+      ...sch.platforms.map(p => `--${p}`),
+      "--privacy",
+      sch.privacy,
+      "--tiktok-privacy",
+      sch.tiktok_privacy,
+      "--confirm",
+      ...(sch.republish ? ["--again"] : []),
+    ],
+    {
+      cwd: ROOT,
+      encoding: "utf8",
+      timeout: 45 * 60_000,
+      maxBuffer: 16 * MB,
+      env: { ...process.env, OMNIVIDEO_ORIGIN: "schedule", OMNIVIDEO_SCHEDULED_FOR: sch.when },
+    },
+  );
+  process.stdout.write(r.stdout ?? "");
+  process.stderr.write(r.stderr ?? "");
+
+  const after = readJson(file) ?? {};
+  const outcome = attemptOutcome({
+    sch,
+    after,
+    startedAt,
+    reason: () => failureReason({ stderr: r.stderr, error: r.error, status: r.status }),
+    now: Date.now(),
+    settings: P.schedule,
+  });
+  if (outcome.done) {
+    delete after.schedule;
+    writePub(file, after);
+    console.log(`${nowIso()} ${name}: publicado`);
+    return;
+  }
+  after.schedule = outcome.schedule;
+  writePub(file, after);
+  const { missing, giveUp, reason } = outcome;
+  console.log(
+    `${nowIso()} ${name}: ${giveUp ? `falhou em ${missing.join(", ")}, desisti depois de ${outcome.schedule.attempts} tentativas` : `falhou em ${missing.join(", ")}, tento de novo em ${P.schedule.interval_min} min`}: ${reason}`,
+  );
+}
+
+/* --- the launchd agent ---------------------------------------------------------------
+   Runs `scheduler run` every 60 s with the node that installed it. PATH goes along because
+   launchd starts with a minimal PATH, without ffprobe, cloudflared or claude. */
+const domain = () => `gui/${process.getuid()}`;
+const launchctl = (...a) => spawnSync("launchctl", a, { encoding: "utf8" });
+
+function agentStatus() {
+  const installed = existsSync(PLIST);
+  let node = null;
+  if (installed) {
+    try {
+      node =
+        /<key>ProgramArguments<\/key>\s*<array>\s*<string>([^<]+)<\/string>/.exec(readFileSync(PLIST, "utf8"))?.[1] ??
+        null;
+    } catch {
+      /* unreadable */
+    }
+  }
+  return {
+    installed,
+    loaded: installed && launchctl("print", `${domain()}/${AGENT}`).status === 0,
+    node_ok: !!node && existsSync(node),
+    log: LOG_FILE,
+  };
+}
+
+function installAgent() {
+  const x = s => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const path = [
+    ...new Set([
+      dirname(process.execPath),
+      "/opt/homebrew/bin",
+      "/usr/local/bin",
+      ...(process.env.PATH ?? "").split(":"),
+      "/usr/bin",
+      "/bin",
+      "/usr/sbin",
+      "/sbin",
+    ]),
+  ]
+    .filter(Boolean)
+    .join(":");
+  mkdirSync(SCHEDULE_DIR, { recursive: true });
+  mkdirSync(dirname(PLIST), { recursive: true });
+  writeFileSync(
+    PLIST,
+    `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${AGENT}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${x(process.execPath)}</string>
+    <string>${x(SELF)}</string>
+    <string>scheduler</string>
+    <string>run</string>
+  </array>
+  <key>WorkingDirectory</key><string>${x(ROOT)}</string>
+  <key>EnvironmentVariables</key>
+  <dict><key>PATH</key><string>${x(path)}</string>${homeEnvPlist(x)}</dict>
+  <key>StartInterval</key><integer>60</integer>
+  <key>RunAtLoad</key><true/>
+  <key>StandardOutPath</key><string>${x(LOG_FILE)}</string>
+  <key>StandardErrorPath</key><string>${x(LOG_FILE)}</string>
+</dict>
+</plist>
+`,
+  );
+  /* reinstalling replaces what was loaded; launchd sometimes takes a moment to release the old one */
+  launchctl("bootout", `${domain()}/${AGENT}`);
+  let r;
+  for (let i = 0; i < 6; i++) {
+    r = launchctl("bootstrap", domain(), PLIST);
+    if (r.status === 0) break;
+    spawnSync("sleep", ["0.5"]);
+  }
+  if (r.status !== 0) fail(`launchctl bootstrap: ${(r.stderr || r.stdout).trim()}`);
+  console.log(
+    `agente da agenda ligado: confere a cada minuto, com o studio aberto ou não (log em .schedule/schedule.log)`,
+  );
+}
+
+function uninstallAgent() {
+  launchctl("bootout", `${domain()}/${AGENT}`);
+  try {
+    unlinkSync(PLIST);
+  } catch {
+    /* was not there */
+  }
+  const n = scheduled().filter(i => ["scheduled", "publishing"].includes(i.sch.state)).length;
+  console.log(`agente da agenda desligado${n ? `: ${n} agendamento(s) ficam parados até você ligar de novo` : ""}`);
+}
+
+/* ============================================================================ */
+const [cmd, sub] = args;
+const isVideo = p => p && !p.startsWith("--") && existsSync(join(resolve(p), "scenes.json"));
+try {
+  if (cmd === "status") await status();
+  else if (cmd === "auth" && sub === "youtube") await authYoutube();
+  else if (cmd === "auth" && sub === "tiktok") await authTiktok();
+  else if (cmd === "auth" && sub === "instagram") await authInstagram(args[2] ?? process.env.OMNIVIDEO_IG_TOKEN);
+  else if (cmd === "text" && isVideo(sub)) text(resolve(sub));
+  else if (cmd === "cover" && isVideo(sub)) {
+    const c = videoCover(resolve(sub));
+    console.log(
+      c
+        ? `capa: thumbnail ${c.version} (${(statSync(c.jpg).size / 1024).toFixed(0)} KB em JPG) vai para o YouTube e o Instagram; o TikTok leva o quadro de cover_at_s`
+        : "sem thumbnail selecionada: cada plataforma usa um quadro do vídeo",
+    );
+    if (c) unlinkSync(c.jpg);
+  } else if (cmd === "schedule" && isVideo(sub)) await schedule(resolve(sub));
+  else if (cmd === "carousel" && sub && existsSync(join(resolve(sub), "carousel", "carousel.json")))
+    await publishCarousel(resolve(sub));
+  else if (cmd === "scheduler" && (!sub || sub === "--json")) listSchedule();
+  else if (cmd === "scheduler" && sub === "run") await runScheduler();
+  else if (cmd === "cloud" && sub === "push") await cloudPush();
+  else if (cmd === "scheduler" && sub === "install") installAgent();
+  else if (cmd === "scheduler" && sub === "uninstall") uninstallAgent();
+  else if (isVideo(cmd)) await publish(resolve(cmd));
+  else {
+    const source = readFileSync(fileURLToPath(import.meta.url), "utf8").split("\n");
+    console.log(
+      source
+        .slice(
+          1,
+          source.findIndex((l, i) => i > 1 && /^\s*=+\s*\*\/\s*$/.test(l)),
+        )
+        .join("\n"),
+    );
+    process.exit(2);
+  }
+} catch (e) {
+  fail(e.message);
+}