@crievo/omni 0.0.0-stage → 0.1.1

package/tools/omnichat.mjs

@@ -0,0 +1,1577 @@
+#!/usr/bin/env node
+/* ============================================================================
+   Omnichat on Instagram comments, like ManyChat: whoever comments the keyword
+   on the post (Reel, carousel or photo) gets a DM with the link (the comment's
+   private reply) and a public reply on the comment ("te mandei no direct").
+
+   Each target is a dir with publication.json (the media id on Instagram):
+     videos/<slug>             the video's Reel
+     videos/<slug>/carousel    the carousel of the same content (tools/carousel.mjs)
+     .omnichat/posts/<code>    a post that did not come from omnivideo (Reel, carousel or photo)
+
+     node tools/omnichat.mjs status [--json]        token, permissions, agent and rules
+     node tools/omnichat.mjs rule videos/<slug> [options]   creates or changes the video's rule
+         --keyword QUERO           triggers on this word or phrase (repeat for more than one);
+                                   case, accents and punctuation don't count
+         --any                     any comment triggers (--keywords to go back)
+         --no-generic              only the keyword; by default "quero", "me manda" and the like
+                                   also trigger, with Claude reading the context when the request
+                                   comes mid-sentence (--generic to go back)
+         --offer "text"            what the DM delivers, in words, for Claude to read the context
+                                   (without it, the post caption and the link are used)
+         --link https://…          what the DM delivers
+         --dm "text"               the DM; {username}, {link} and {post} are replaced (without {link}, it goes at the end)
+         --quote-post              the commented post's link on the DM's first line (without {post} in the text):
+                                   Instagram shows the post card on top and the message reads as a reply
+                                   to it (--no-quote-post to remove; a new rule follows omnichat.instagram.quote_post)
+         --public-reply "text"     public reply, one picked at random per comment (repeat for
+                                   more than one); --no-public-reply replies only by DM
+         --button                  the DM opens with a button ("Quero o link") and the link goes out when the person taps it
+                                   (needs the webhook: node tools/omnichat.mjs webhook setup); --no-button to remove
+         --require-follow          the tap only delivers if the person follows the account; otherwise they get
+                                   "follow and tap again" with a new button (implies --button; --no-require-follow)
+         --opening-dm "text"       the text above the button ({username} is replaced)
+         --button-label "text"     the button's label, up to 20 characters
+         --not-following-dm "text" what goes out when someone taps without following
+         --retry-label "text"      the button of that message, up to 20 characters ("Pronto, já sigo!")
+         --no-follow-skip          whoever taps "já sigo" again without following gets no "Receber sem seguir"
+                                   (on by default with --require-follow; --follow-skip to go back)
+         --skip-label "text"       that button's label, up to 20 characters ("Receber sem seguir")
+         --skip-dm "text"          the DM of whoever gets the link through that button ({username} and {link} are replaced)
+         --link-button             the link goes in a button that opens it ("Abrir link"), not in the DM's text
+                                   ({link} leaves the text); --no-link-button to go back
+         --link-label "text"       that button's label, up to 20 characters
+         --answered skip|send      comment the account already replied to by hand: skip (default) or send
+         --answered-if "text"      with send, only when your reply says this (repeat for more)
+         --json '{…}'              the same fields at once (the studio uses it; also generic_phrases, offer, quote_post, already_replied, already_replied_if)
+     node tools/omnichat.mjs post <post link> [rule options]   a post that is already live (Reel,
+         carousel or photo, a /reel/ or /p/ link) and did not come from omnivideo: creates
+         .omnichat/posts/<code>/, which works where videos/<slug> does; an omnivideo post uses its own dir
+     node tools/omnichat.mjs enable videos/<slug> --confirm    starts replying
+     node tools/omnichat.mjs disable videos/<slug>       also without a rule: it is the "don't enable on your own at publish"
+     node tools/omnichat.mjs published videos/<slug>[/carousel] [--plan]   publish.mjs calls it when the Reel
+         (or the carousel) goes up: with omnichat.instagram.enable_on_publish, enables the rule (without a
+         rule, it is born from the narration's or the script's "comenta X que eu te mando" and the link
+         found in the content)
+     node tools/omnichat.mjs test videos/<slug> "comment"  triggers? what would it send? (no API)
+     node tools/omnichat.mjs run [videos/<slug>] [--dry-run]  one pass (the agent calls it every minute)
+         --dry-run                 reads the comments and shows what it would do, without sending or writing anything
+     node tools/omnichat.mjs log videos/<slug> [--json]
+     node tools/omnichat.mjs retry videos/<slug>       what failed without a DM goes back to the queue (within the 7 days)
+     node tools/omnichat.mjs comments videos/<slug> [--json]   fetches the post now and lists who did not
+         get the DM: what the rule skipped, has not picked up yet or does not trigger, and what failed
+     node tools/omnichat.mjs delete videos/<slug> <id> [<id>…] --confirm   deletes comments on the post (people's or
+         the account's own replies) on Instagram: it cannot be undone. A reply that was waiting in the queue is skipped.
+     node tools/omnichat.mjs send videos/<slug> <id> [<id>…] --confirm   the rule's DM to the chosen
+         comments, by hand, even the ones that did not trigger (up to max_per_pass at a time)
+         --no-public-reply         only the DM, without the reply on the comment
+         --public-reply "text"     the reply on the comment written by you, instead of the rule's
+                                   random ones ({username} is replaced)
+         --public-reply-only       only the reply on the comment, without the DM: works past the 7 days
+                                   and without a rule (then with --public-reply)
+     node tools/omnichat.mjs webhook setup | subscribe | status | serve [--port 5434]
+         the messaging webhook that the button and the follow gate need: `setup` creates the verify token and says
+         what to paste in the Meta panel, `subscribe` signs the account up to messages and postbacks, `serve` listens
+         (behind a tunnel: cloudflared tunnel --url http://127.0.0.1:5434)
+     node tools/omnichat.mjs cloud status | push [videos/<slug>] [--records] [--force] | pull videos/<slug>
+         the Worker in cloud/omnichat (cloud.url in the config, OMNICHAT_CLOUD_SECRET in the .env):
+         `push` sends the config, the Instagram account and the rules (with --records, the local records too,
+         once: --force overwrites one the cloud already wrote); with cloud.omnichat the cloud answers, every
+         saved rule goes up on its own, the record is read from there and the local agent and webhook step aside
+     node tools/omnichat.mjs agent [--json] | install | uninstall
+
+   Replying goes outside, on behalf of the account: the rule is born disabled and only
+   enables at the user's request (the studio switch, or `enable --confirm`) or, when the post
+   goes up, with omnichat.instagram.enable_on_publish, the config's permanent approval. The
+   launchd agent only reads and replies to targets with the rule enabled and the post published.
+
+   Comments go by polling (phase 1); only the button's tap needs the webhook (phase 2, below). The comments
+   webhook needs a Live app, Advanced Access and
+   Business Verification, so the agent polls the API every minute: it reads the
+   comments_count of each post with an enabled rule and only fetches comments when
+   it changes. Older posts are checked less often (omnichat.instagram.interval_min).
+   Meta allows one private reply per comment, up to 7 days after it: with the Mac
+   asleep, the agent replies when it wakes, within that deadline.
+
+   The DM goes first. Only once it is delivered does the public reply go: without a DM,
+   "te mandei no direct" would be a lie. Meta rate limits or blocks stop everything for
+   a while (rate_limit_pause_min); a transient error retries on the next pass, up to
+   `attempts` times.
+
+   Files (in each target; below, the video's): videos/<slug>/omnichat.json is the rule (you, via the studio or via
+   `rule`); videos/<slug>/omnichat-record.json is what this tool has done
+   (only it writes). Agent lock, pause and log in .omnichat/.
+   Token: the same as publish.mjs, with instagram_business_manage_comments and
+   instagram_business_manage_messages on top of the publishing ones (reference/omnichat.md).
+   ============================================================================ */
+
+/* The decisions (matching, the pass, the texts, sending by hand) live in tools/lib/omnichat/ and the
+   Instagram calls in tools/lib/platforms/instagram.mjs; this file is the CLI: files, flags, the lock,
+   the launchd agent and the Claude classifier for uncertain comments. */
+
+import {
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  existsSync,
+  readdirSync,
+  mkdirSync,
+  openSync,
+  writeSync,
+  closeSync,
+  unlinkSync,
+  realpathSync,
+} from "node:fs";
+import { spawnSync, spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve, dirname, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  env,
+  writeEnv,
+  sleep,
+  instagramToken,
+  instagramAccount,
+  igClient,
+  cloudSettings,
+  cloudApi,
+  runnerStatus,
+} from "./platforms.mjs";
+import { resolveOmnichatConfig } from "./lib/omnichat/config.mjs";
+import { askText } from "./lib/agents.mjs";
+import { triggers } from "./lib/omnichat/match.mjs";
+import {
+  deliveryPreview,
+  skipDeliveryPreview,
+  publicReplyText as corePublicReplyText,
+  newRule as coreNewRule,
+  ruleProblems as coreRuleProblems,
+  toList,
+  applyRuleJson,
+  offerText,
+  gateOn,
+  openingText,
+  buttonLabel,
+  classifyPrompt,
+  classifyInput,
+  parseClassification,
+  SAMPLE_POST,
+  SAMPLE_CAROUSEL,
+} from "./lib/omnichat/text.mjs";
+import { linkIn, keywordIn } from "./lib/omnichat/extract.mjs";
+import { PauseError, pauseFor, isPaused } from "./lib/omnichat/errors.mjs";
+import { runPass } from "./lib/omnichat/pass.mjs";
+import {
+  recordItems as coreRecordItems,
+  totals,
+  retryFailed,
+  thread,
+  withoutDm,
+  publishedPlan,
+} from "./lib/omnichat/record.mjs";
+import { sendManual } from "./lib/omnichat/manual.mjs";
+import { handleWebhook, WEBHOOK_FIELDS } from "./lib/omnichat/webhook.mjs";
+import { isMainModule, homeEnvPlist, DATA_ROOT as ROOT } from "./lib/paths.mjs";
+
+const CFG = JSON.parse(readFileSync(join(ROOT, "omnivideo.config.json"), "utf8"));
+const C = resolveOmnichatConfig(CFG.omnichat?.instagram ?? {});
+
+const DIR = join(ROOT, ".omnichat");
+const LOCK_FILE = join(DIR, "running.lock");
+const PAUSE_FILE = join(DIR, "pause.json");
+const LOG_FILE = join(DIR, "omnichat.log");
+const POSTS = join(DIR, "posts");
+const AGENT_LABEL = "com.omnivideo.omnichat";
+const PLIST = join(homedir(), "Library", "LaunchAgents", `${AGENT_LABEL}.plist`);
+const SELF = fileURLToPath(import.meta.url);
+
+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];
+};
+const options = n => args.flatMap((a, i) => (a === `--${n}` && args[i + 1] != null ? [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 nowIso = () => new Date().toISOString();
+const dayTime = iso =>
+  new Date(iso).toLocaleString("pt-BR", { day: "2-digit", month: "2-digit", hour: "2-digit", minute: "2-digit" });
+
+function writeJson(file, data) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
+  renameSync(tmp, file);
+}
+const log = line => console.log(line);
+
+/* --- the target -------------------------------------------------------------------------
+   The carousel dir (videos/<slug>/carousel) is a target like the video's: its name in the log and
+   in messages is <slug>/carousel, and what it does not say (the link, the keyword) comes from the content. */
+const isCarousel = dir => basename(dir) === "carousel" && existsSync(join(dir, "carousel.json"));
+const nameOf = dir => (isCarousel(dir) ? `${basename(dirname(dir))}/carousel` : basename(dir));
+const thePost = dir => (isCarousel(dir) ? "o carrossel" : "o post");
+const thisTarget = dir =>
+  isCarousel(dir) ? "este carrossel" : dir.startsWith(POSTS + "/") ? "este post" : "este vídeo";
+
+/* --- the rule (files) -------------------------------------------------------------------- */
+const ruleFile = dir => join(dir, "omnichat.json");
+const recordFile = dir => join(dir, "omnichat-record.json");
+const ruleOf = dir => readJson(ruleFile(dir))?.instagram ?? null;
+const newRule = () => coreNewRule(C);
+const ruleProblems = r => coreRuleProblems(r, C);
+/* what the delivery sends, in one line: with link_button, the text and [label → link] */
+const deliveryLine = (rule, username, post) => deliveryPreview(rule, username, post, C);
+const publicReplyText = (rule, username) => corePublicReplyText(rule, username, C);
+const sampleFor = dir => (isCarousel(dir) ? SAMPLE_CAROUSEL : SAMPLE_POST);
+const postOf = dir => readJson(join(dir, "publication.json"))?.instagram?.url ?? null;
+const mediaOf = dir => readJson(join(dir, "publication.json"))?.instagram?.id ?? null;
+
+/* The agent reads the uncertain comments with what the post offers and says which ask for the
+   delivery: the core's injected classifier, on this machine. Runs on the agent accounts in rotation
+   (tools/lib/agents.mjs; ~/.claude is never used), Claude with the omnichat.instagram.context_model
+   model. Returns { id: true|false } and, if no agent answers, null: the comment stays uncertain. */
+const runAsync = input => (bin, args, env) =>
+  new Promise(done => {
+    const p = spawn(bin, args, { cwd: ROOT, env });
+    let stdout = "",
+      stderr = "";
+    const timer = setTimeout(() => p.kill(), 120_000);
+    p.stdout.on("data", d => {
+      stdout += d;
+    });
+    p.stderr.on("data", d => {
+      stderr += d;
+    });
+    p.on("error", error => {
+      clearTimeout(timer);
+      done({ error, stdout, stderr });
+    });
+    p.on("close", status => {
+      clearTimeout(timer);
+      done({ status, stdout, stderr });
+    });
+    p.stdin.end(input);
+  });
+
+const classifierFor = (dir, rule) => async items => {
+  if (!items.length) return {};
+  const prompt = classifyPrompt(offerText(rule, readJson(join(dir, "publication.json"))));
+  const result = await askText(
+    { root: ROOT, cfg: CFG, prompt, claudeModel: C.context_model, tmpDir: tmpdir() },
+    runAsync(classifyInput(items)),
+  ).then(
+    r => ({ out: r.text }),
+    e => ({ error: e.message }),
+  );
+  if (result.error) {
+    console.log(
+      `${nowIso()} ${nameOf(dir)}: o agente não decidiu ${items.length} comentário(s) em dúvida: ${result.error}`,
+    );
+    return null;
+  }
+  try {
+    return parseClassification(result.out);
+  } catch {
+    console.log(`${nowIso()} ${nameOf(dir)}: o agente não devolveu JSON: ${result.out.trim().slice(0, 120)}`);
+    return null;
+  }
+};
+
+function rule(dir) {
+  const file = ruleFile(dir);
+  const all = readJson(file) ?? {};
+  const before = all.instagram ?? newRule();
+  const r = { ...before };
+  const json = option("json");
+  if (json != null) {
+    let j;
+    try {
+      j = JSON.parse(json);
+    } catch (e) {
+      fail(`--json: ${e.message}`);
+    }
+    applyRuleJson(r, j);
+  }
+  if (options("keyword").length) r.keywords = toList(options("keyword"));
+  if (has("any")) r.any_comment = true;
+  if (has("keywords")) r.any_comment = false;
+  if (option("link") !== undefined) r.link = option("link").trim();
+  if (option("dm") !== undefined) r.dm = option("dm").trim();
+  if (options("public-reply").length) r.public_replies = toList(options("public-reply").join("\n").split("\n"));
+  if (has("no-public-reply")) r.public_replies = [];
+  if (has("no-generic")) r.generic_phrases = false;
+  if (has("generic")) r.generic_phrases = true;
+  if (option("offer") !== undefined) r.offer = option("offer").trim();
+  if (has("quote-post")) r.quote_post = true;
+  if (has("no-quote-post")) r.quote_post = false;
+  if (has("button")) r.button = true;
+  if (has("no-button")) r.button = false;
+  if (has("require-follow")) r.require_follow = true;
+  if (has("no-require-follow")) r.require_follow = false;
+  if (option("opening-dm") !== undefined) r.opening_dm = option("opening-dm").trim();
+  if (option("button-label") !== undefined) r.button_label = option("button-label").trim();
+  if (option("not-following-dm") !== undefined) r.not_following_dm = option("not-following-dm").trim();
+  if (option("retry-label") !== undefined) r.retry_label = option("retry-label").trim();
+  if (has("link-button")) r.link_button = true;
+  if (has("no-link-button")) r.link_button = false;
+  if (option("link-label") !== undefined) r.link_label = option("link-label").trim();
+  if (has("follow-skip")) r.follow_skip = true;
+  if (has("no-follow-skip")) r.follow_skip = false;
+  if (option("skip-label") !== undefined) r.skip_label = option("skip-label").trim();
+  if (option("skip-dm") !== undefined) r.skip_dm = option("skip-dm").trim();
+  if (option("answered") !== undefined) {
+    if (!["skip", "send"].includes(option("answered"))) fail("--answered skip|send");
+    r.already_replied = option("answered");
+  }
+  if (options("answered-if").length) r.already_replied_if = toList(options("answered-if").join("\n").split("\n"));
+
+  const problems = ruleProblems(r);
+  /* an enabled rule that stopped adding up is not written; a disabled one keeps the draft */
+  if (problems.length && r.enabled) fail("a regra está ligada e não ficaria de pé:\n  " + problems.join("\n  "));
+  r.updated_at = nowIso();
+  all.instagram = r;
+  writeJson(file, all);
+  syncRule(dir);
+  if (has("json")) {
+    console.log(JSON.stringify({ rule: r, problems }));
+    return;
+  }
+  describe(dir, r);
+  if (problems.length) console.log("falta para ligar:\n  " + problems.join("\n  "));
+  else if (!r.enabled)
+    console.log(`desligada: para responder, node tools/omnichat.mjs enable ${relativePath(dir)} --confirm`);
+}
+
+const relativePath = dir => (dir.startsWith(ROOT + "/") ? dir.slice(ROOT.length + 1) : dir);
+
+function describe(dir, r) {
+  console.log(`${nameOf(dir)}: ${r.enabled ? "ligada" : "desligada"}`);
+  console.log(
+    `  dispara: ${r.any_comment ? "qualquer comentário" : (r.keywords ?? []).map(p => `"${p}"`).join(", ") || "(sem palavra)"}${!r.any_comment && r.generic_phrases !== false ? ` e os pedidos genéricos (${C.generic_phrases.map(g => `"${g}"`).join(", ")}), com o Claude lendo o contexto quando vêm no meio de uma frase` : ""}`,
+  );
+  const dm = deliveryLine(r, "fulano", postOf(dir) ?? sampleFor(dir)).replace(/\n/g, " ⏎ ");
+  if (gateOn(r)) {
+    console.log(`  DM: ${openingText(r, "fulano", C)} [${buttonLabel(r, C)}]`);
+    console.log(`  ao tocar${r.require_follow ? ", se seguir a conta" : ""}: ${dm}`);
+    if (r.require_follow)
+      console.log(
+        `  se não seguir: pede para seguir e toca de novo${r.follow_skip !== false ? `; na segunda vez, com "${r.skip_label || C.default_skip_label}"` : ""}`,
+      );
+    if (r.require_follow && r.follow_skip !== false)
+      console.log(
+        `  ao receber sem seguir: ${skipDeliveryPreview(r, "fulano", postOf(dir) ?? sampleFor(dir), C).replace(/\n/g, " ⏎ ")}`,
+      );
+  } else console.log(`  DM: ${dm}`);
+  const pub = r.public_replies ?? C.default_public_replies;
+  console.log(`  pública: ${pub.length ? pub.map(t => `"${t}"`).join(" | ") : "nenhuma (só DM)"}`);
+  const ifSays = r.already_replied_if ?? [];
+  console.log(
+    `  já respondidos por você: ${r.already_replied === "send" ? `manda${ifSays.length ? ` se a sua resposta disser ${ifSays.map(t => `"${t}"`).join(" ou ")}` : " mesmo assim"}` : "pula"}`,
+  );
+}
+
+function enable(dir) {
+  if (!has("confirm")) fail("ligar é responder para fora, em nome da conta: só com pedido do usuário (--confirm)");
+  const file = ruleFile(dir);
+  const all = readJson(file);
+  if (!all?.instagram)
+    fail(
+      `${thisTarget(dir)} não tem regra: node tools/omnichat.mjs rule ${relativePath(dir)} --keyword QUERO --link https://…`,
+    );
+  const problems = ruleProblems(all.instagram);
+  if (problems.length) fail("a regra ainda não fecha:\n  " + problems.join("\n  "));
+  all.instagram = { ...all.instagram, enabled: true, enabled_at: nowIso() };
+  writeJson(file, all);
+  syncRule(dir);
+  describe(dir, all.instagram);
+  if (!readJson(join(dir, "publication.json"))?.instagram?.id)
+    console.log(`${thePost(dir)} ainda não foi publicado: começa a responder quando ele subir`);
+  if (!agentStatus().loaded)
+    console.log("aviso: o agente está desligado e nada é respondido sozinho: node tools/omnichat.mjs agent install");
+}
+
+/* disabling without an enabled rule also writes: it is the "don't enable on your own" that `published` respects */
+function disable(dir) {
+  const file = ruleFile(dir);
+  const all = readJson(file) ?? {};
+  if (!all.instagram?.enabled && all.instagram?.disabled_at) {
+    console.log("já estava desligada");
+    return;
+  }
+  const already = all.instagram && !all.instagram.enabled;
+  all.instagram = { ...(all.instagram ?? newRule()), enabled: false, disabled_at: nowIso() };
+  writeJson(file, all);
+  syncRule(dir);
+  console.log(
+    `${nameOf(dir)}: ${already || !all.instagram.enabled_at ? "fica desligada" : "desligada"}${C.enable_on_publish ? `, e não liga sozinha quando ${thePost(dir)} subir` : ""}`,
+  );
+}
+
+/* what failed without a delivered DM goes back to the queue (after swapping the token, for example);
+   past Meta's deadline there is no way back */
+async function retry(dir) {
+  if (cloudOwns()) {
+    const media = mediaOf(dir);
+    if (!media) fail(`${thePost(dir)} ainda não foi publicado`);
+    const { n, old } = await cloudApi("POST", `/api/posts/${media}/retry`, {});
+    await pullRecord(dir);
+    console.log(n ? `${n} comentário(s) de volta na fila da cloud` : "nada para refazer");
+    if (old) console.log(`${old} passaram dos 7 dias e não podem mais receber a DM`);
+    return;
+  }
+  const file = recordFile(dir);
+  const all = readJson(file);
+  const { n, old } = retryFailed(all?.instagram, Date.now());
+  if (n) writeJson(file, all);
+  if (n && existsSync(PAUSE_FILE)) unlinkSync(PAUSE_FILE);
+  console.log(
+    n
+      ? `${n} comentário(s) de volta na fila${ruleOf(dir)?.enabled ? "" : " (a regra está desligada: ligue para responder)"}`
+      : "nada para refazer",
+  );
+  if (old) console.log(`${old} passaram dos 7 dias e não podem mais receber a DM`);
+}
+
+async function test(dir, comment) {
+  const r = ruleOf(dir);
+  if (!r) fail(`${thisTarget(dir)} não tem regra`);
+  if (comment == null) fail('passe o comentário: node tools/omnichat.mjs test videos/<slug> "quero o link"');
+  let d = triggers(r, comment, C);
+  if (d === "uncertain") {
+    const resp = await classifierFor(dir, r)([["t", { text: comment }]]);
+    if (!resp) fail("o comentário ficou em dúvida e o Claude não respondeu");
+    console.log(`pedido no meio de uma frase: o Claude ${resp.t === true ? "leu como pedido" : "não leu como pedido"}`);
+    d = resp.t === true ? "yes" : false;
+  }
+  if (!d) {
+    console.log(`não dispara: "${comment}"`);
+    return;
+  }
+  console.log(`dispara: "${comment}"`);
+  const dm = deliveryLine(r, "fulano", postOf(dir) ?? sampleFor(dir)).replace(/\n/g, " ⏎ ");
+  if (gateOn(r)) {
+    console.log(`  DM: ${openingText(r, "fulano", C)} [${buttonLabel(r, C)}]`);
+    console.log(`  ao tocar${r.require_follow ? " (seguindo a conta)" : ""}: ${dm}`);
+  } else console.log(`  DM: ${dm}`);
+  const p = publicReplyText(r, "fulano");
+  console.log(`  pública: ${p ?? "nenhuma (só DM)"}`);
+}
+
+/* --- one pass: the core's runPass, on this target's files -------------------------------- */
+async function runTarget(dir, account, dryRun) {
+  const rule = ruleOf(dir);
+  const name = nameOf(dir);
+  const media = mediaOf(dir);
+  if (!media) {
+    if (dryRun) console.log(`${name}: ${thePost(dir)} ainda não foi publicado`);
+    return;
+  }
+  const recFile = recordFile(dir);
+  const all = readJson(recFile) ?? {};
+  await runPass({
+    rule,
+    media,
+    stored: all.instagram,
+    account,
+    name,
+    postFallback: postOf(dir),
+    dryRun,
+    classify: classifierFor(dir, rule),
+    save: r => {
+      all.instagram = r;
+      writeJson(recFile, all);
+    },
+    C,
+    log,
+  });
+}
+
+/* --- by hand: who was left without the DM, and the chosen sending -----------------------------
+   `comments` reads the post now, without waiting for the agent, and lists who did not get the DM:
+   what the rule skipped (already replied by you, Claude read it as something else), what has not
+   been picked up yet, what failed and what does not trigger. Read only: nothing is written.
+   `send` sends the rule's DM (and the public reply, unless --no-public-reply) to the chosen
+   comments, even ones that don't trigger: it goes outside, on behalf of the account, and needs
+   --confirm. Goes at the agent's pace (pause_between_s, up to max_per_pass at a time), with its
+   lock, and respects the account pause; the record gets `manual: true`, and whoever already got
+   it does not get it again. What fails transiently the agent retries, like its own.
+   --public-reply replaces the rule's random replies with the written text. --public-reply-only
+   replies only on the comment, without a DM: it has no 7-day deadline nor needs the rule, goes once
+   (does not go back to the queue) and a new comment in the record is skipped, like one you reply to in the app. */
+async function comments(dir) {
+  const media = mediaOf(dir);
+  if (!media) fail(`${thePost(dir)} ainda não foi publicado`);
+  const rule = ruleOf(dir);
+  await pullRecord(dir);
+  const { token } = await instagramToken();
+  /* `next` is left when the read stopped at the page limit: the newest comments only */
+  const { read, next } = await igClient(token).comments(media, 0);
+  const truncated = !!next;
+  const us = (await instagramAccount(token)).username?.toLowerCase() ?? "";
+  const rec = readJson(recordFile(dir))?.instagram?.comments ?? {};
+  const items = withoutDm({ read, us, rec, rule, now: Date.now(), C });
+  const post = (await igClient(token).media(media, "permalink")).permalink ?? postOf(dir);
+  const chat = thread({ read, us, rec, rule, now: Date.now(), post, C });
+  const s = { checked_at: nowIso(), read: read.length, truncated, without_dm: items.length, items, thread: chat };
+  if (has("json")) {
+    console.log(JSON.stringify(s));
+    return;
+  }
+  console.log(
+    `${nameOf(dir)}: ${read.length} comentário(s) lido(s)${truncated ? ` (só os ${read.length} mais novos)` : ""}, ${items.length} sem DM`,
+  );
+  for (const c of items) {
+    const marks = [
+      c.triggers === "yes" ? "pede" : c.triggers === "uncertain" ? "talvez peça" : null,
+      c.state && `${c.state}${c.reason ? `: ${c.reason}` : ""}`,
+      c.account_reply && "você respondeu no comentário",
+      !c.within_deadline && "passou dos 7 dias",
+    ]
+      .filter(Boolean)
+      .join(" · ");
+    console.log(
+      `${c.id}  ${dayTime(c.commented_at)}  @${(c.username ?? "?").padEnd(20)} "${c.text.slice(0, 50)}"${marks ? `  ${marks}` : ""}`,
+    );
+  }
+}
+
+/* Deletes comments on Instagram (a person's on the post, or the account's own reply). It goes outside and
+   does not come back: --confirm. A comment the agent still had queued stops waiting (the record keeps it,
+   with the DM that went, if one did); with the cloud answering, its record is not touched from here. */
+async function remove(dir, ids) {
+  if (!has("confirm")) fail("apagar não tem volta: só com pedido do usuário (--confirm)");
+  ids = [...new Set(ids)];
+  if (!ids.length || ids.some(i => !/^\d+$/.test(i)))
+    fail("passe os ids dos comentários: node tools/omnichat.mjs delete videos/<slug> <id> [<id>…] --confirm");
+  if (!mediaOf(dir)) fail(`${thePost(dir)} ainda não foi publicado`);
+  const { token } = await instagramToken();
+  const client = igClient(token);
+  const results = [];
+  for (const id of ids) {
+    try {
+      await client.deleteComment(id);
+      results.push({ id, state: "done", reason: null });
+    } catch (e) {
+      results.push({ id, state: "failed", reason: e.message });
+    }
+  }
+  const gone = new Set(results.filter(x => x.state === "done").map(x => x.id));
+  const recFile = recordFile(dir);
+  const all = readJson(recFile);
+  if (gone.size && all?.instagram?.comments && !cloudOwns()) {
+    let changed = false;
+    for (const id of gone) {
+      const c = all.instagram.comments[id];
+      if (!c) continue;
+      c.deleted_at = nowIso();
+      if (c.state === "queued" || c.state === "retry" || c.state === "uncertain")
+        Object.assign(c, { state: "skipped", reason: "apagado por você" });
+      changed = true;
+    }
+    if (changed) writeJson(recFile, all);
+  }
+  if (has("json")) {
+    console.log(JSON.stringify({ deleted: gone.size, results }));
+    return;
+  }
+  for (const x of results) console.log(`${x.id}: ${x.state === "done" ? "apagado" : `falhou: ${x.reason}`}`);
+  console.log(`${gone.size} de ${ids.length} apagados`);
+}
+
+async function send(dir, ids) {
+  if (!has("confirm")) fail("enviar é responder para fora, em nome da conta: só com pedido do usuário (--confirm)");
+  ids = [...new Set(ids)];
+  if (!ids.length || ids.some(i => !/^\d+$/.test(i)))
+    fail("passe os ids dos comentários: node tools/omnichat.mjs send videos/<slug> <id> [<id>…] --confirm");
+  const publicOnly = has("public-reply-only");
+  const written = option("public-reply")?.trim();
+  if (has("public-reply") && !written) fail("--public-reply sem texto");
+  if (written?.length > 2200) fail("resposta no comentário com mais de 2.200 caracteres");
+  if (publicOnly && has("no-public-reply")) fail("--public-reply-only e --no-public-reply não vão juntos");
+  /* the rule's public replies say "te mandei no direct": without a DM, only the written text */
+  if (publicOnly && !written) fail('sem a DM, escreva a resposta: --public-reply-only --public-reply "texto"');
+  const rule = ruleOf(dir);
+  if (!publicOnly) {
+    if (!rule)
+      fail(
+        `este vídeo não tem regra, e a DM sai do texto dela: node tools/omnichat.mjs rule ${relativePath(dir)} --keyword QUERO --link https://…`,
+      );
+    const problems = ruleProblems(rule);
+    if (problems.length) fail("a regra ainda não fecha:\n  " + problems.join("\n  "));
+  }
+  const media = mediaOf(dir);
+  if (!media) fail(`${thePost(dir)} ainda não foi publicado`);
+  /* the cloud answers this post: the send goes through it, under its lease and its pause */
+  if (cloudOwns()) {
+    const out = await cloudApi("POST", `/api/posts/${media}/send`, {
+      ids,
+      public_reply: !has("no-public-reply"),
+      public_reply_only: publicOnly,
+      text: written,
+    });
+    await pullRecord(dir);
+    return printSent(out.results ?? [], ids, publicOnly);
+  }
+  const pause = readJson(PAUSE_FILE);
+  if (isPaused(pause, Date.now())) fail(`em pausa até ${dayTime(pause.until)}: ${pause.reason}`);
+  /* the agent's lock: its pass takes seconds */
+  let release = null;
+  // biome-ignore lint/suspicious/noAssignInExpressions: retry until the lock is taken
+  for (let i = 0; i < 30 && !(release = lock()); i++) await sleep(1000);
+  if (!release) fail("uma passada do agente está demorando: tente de novo em um minuto");
+  const used = has("no-public-reply")
+    ? { ...rule, public_replies: [] }
+    : written
+      ? { ...rule, public_replies: [written] }
+      : rule;
+  let results = [];
+  try {
+    const { token, id } = await instagramToken();
+    const recFile = recordFile(dir);
+    const all = readJson(recFile) ?? {};
+    results = await sendManual({
+      ids,
+      rule: used,
+      publicOnly,
+      written,
+      media,
+      stored: all.instagram,
+      account: { client: igClient(token), id },
+      name: nameOf(dir),
+      postFallback: postOf(dir),
+      save: r => {
+        all.instagram = r;
+        writeJson(recFile, all);
+      },
+      onPause: p => writeJson(PAUSE_FILE, p),
+      C,
+      log,
+    });
+  } finally {
+    release();
+  }
+  printSent(results, ids, publicOnly);
+}
+
+function printSent(results, ids, publicOnly) {
+  const sent = results.filter(x => x.state === "done").length;
+  if (has("json")) {
+    console.log(JSON.stringify({ sent, results }));
+    return;
+  }
+  for (const x of results)
+    console.log(
+      `@${x.username ?? x.id}: ${x.state === "done" ? (publicOnly ? "resposta no comentário" : `DM${x.public_reply ? " e pública" : ""}`) : `${x.state}${x.reason ? `: ${x.reason}` : ""}`}`,
+    );
+  console.log(`${sent} de ${ids.length} ${publicOnly ? "respondidos no comentário" : "com a DM entregue"}`);
+}
+
+/* --- run: every target with an enabled rule ------------------------------------------------ */
+function videosWithRule() {
+  const dirs = [];
+  for (const base of [join(ROOT, "videos"), POSTS]) {
+    try {
+      dirs.push(...readdirSync(base).map(n => join(base, n)));
+    } catch {
+      /* does not exist yet */
+    }
+  }
+  /* each content's carousel is another post, with its own rule */
+  try {
+    dirs.push(...readdirSync(join(ROOT, "videos")).map(n => join(ROOT, "videos", n, "carousel")));
+  } catch {
+    /* no videos/ */
+  }
+  return dirs.filter(p => existsSync(ruleFile(p)));
+}
+
+/* A post that is already live and did not come from omnivideo (or did, and you only have the link):
+   finds the media by the link among the account's posts and creates .omnichat/posts/<code>/ with
+   its publication.json. Works for Reel, carousel and photo (`type` is the media_type). A post that
+   came from omnivideo (a video's Reel, or its carousel) uses its own dir. */
+async function post(target) {
+  if (!target)
+    fail(
+      "passe o link do post (Reel, carrossel ou foto): node tools/omnichat.mjs post https://www.instagram.com/p/…/ --keyword QUERO --link https://…",
+    );
+  const code = /instagram\.com\/(?:[\w.]+\/)?(?:reels?|p|tv)\/([\w-]+)/.exec(target)?.[1];
+  const { token } = await instagramToken();
+  const client = igClient(token);
+  let media = null;
+  let url = client.mediaListUrl("id,permalink,timestamp,media_type,media_product_type", "50");
+  for (let i = 0; url && !media && i < 20; i++) {
+    const j = await client.get(url, "Instagram (posts)");
+    media = (j.data ?? []).find(m => (code ? m.permalink?.includes(`/${code}/`) : m.id === target)) ?? null;
+    url = j.paging?.next ?? null;
+  }
+  if (!media) fail(`não achei ${target} entre os posts de @${(await instagramAccount(token)).username}`);
+  const videoDir = (() => {
+    try {
+      return readdirSync(join(ROOT, "videos"))
+        .flatMap(n => [join(ROOT, "videos", n), join(ROOT, "videos", n, "carousel")])
+        .find(p => readJson(join(p, "publication.json"))?.instagram?.id === media.id);
+    } catch {
+      return null;
+    }
+  })();
+  const dir = videoDir ?? join(POSTS, code ?? media.id);
+  if (!videoDir) {
+    mkdirSync(dir, { recursive: true });
+    writeJson(join(dir, "publication.json"), {
+      instagram: {
+        id: media.id,
+        url: media.permalink,
+        published_at: new Date(Date.parse(media.timestamp)).toISOString(),
+        type: media.media_type ?? null,
+      },
+    });
+  }
+  const type =
+    media.media_product_type === "REELS"
+      ? "Reel"
+      : media.media_type === "CAROUSEL_ALBUM"
+        ? "carrossel"
+        : media.media_type === "IMAGE"
+          ? "foto"
+          : "post";
+  console.log(`${type} ${media.permalink} → ${relativePath(dir)}`);
+  rule(dir);
+}
+
+/* --- what the video already says: the link and the keyword -----------------------------------
+   The studio imports both (the Publish stage shows what it found) and `published` uses them.
+   The scanning is the core's (lib/omnichat/extract.mjs); this side gathers the texts. */
+const readText = file => {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+};
+
+/* The link the DM delivers: the first http(s) URL in the description and caption (publication.json),
+   in brief.md and in source/request.md, in that order. Social network links don't count: they are
+   the post the topic came from, or the published video itself. `found_in` says where it was found ("no brief.md"). */
+export function videoLink(dir) {
+  const pubText = file => {
+    const pub = readJson(file);
+    return [pub?.description, pub?.caption, pub?.caption_instagram].filter(s => typeof s === "string").join("\n");
+  };
+  /* the carousel: its caption and script first; then what the content (the parent dir) says */
+  const sources = isCarousel(dir)
+    ? [
+        [
+          "na legenda do carrossel",
+          [pubText(join(dir, "publication.json")), readJson(join(dir, "carousel.json"))?.caption ?? ""].join("\n"),
+        ],
+        ["no roteiro do carrossel", readText(join(dir, "script.md")) ?? ""],
+        ["na descrição da publicação do vídeo", pubText(join(dirname(dir), "publication.json"))],
+        ["no brief.md", readText(join(dirname(dir), "brief.md")) ?? ""],
+        ["no source/request.md", readText(join(dirname(dir), "source", "request.md")) ?? ""],
+      ]
+    : [
+        ["na descrição da publicação", pubText(join(dir, "publication.json"))],
+        ["no brief.md", readText(join(dir, "brief.md")) ?? ""],
+        ["no source/request.md", readText(join(dir, "source", "request.md")) ?? ""],
+      ];
+  const found = linkIn(sources);
+  if (found) return found;
+  /* the carousel of a video that already delivers a link through omnichat delivers the same */
+  const fromVideo = isCarousel(dir) ? String(ruleOf(dirname(dir))?.link ?? "").trim() : "";
+  return fromVideo ? { link: fromVideo, found_in: "na regra do omnichat do vídeo" } : null;
+}
+
+/* The keyword the narration asks for: "Comenta REA que eu te mando o link", "comente muse que te envio".
+   The scenes.json lines first, which is what the voice says; then the script.
+   In the carousel: the slides' text and carousel.json's caption, then its script. */
+export function narrationKeyword(dir) {
+  const scenes = readJson(join(dir, "scenes.json"))?.scenes ?? [];
+  const car = isCarousel(dir) ? readJson(join(dir, "carousel.json")) : null;
+  return keywordIn([
+    ...scenes.flatMap(s => (s.lines ?? []).map(l => l.text ?? "")),
+    ...(car ? [...(car.slides ?? []).map(s => [s.title, s.text].filter(Boolean).join(" ")), car.caption ?? ""] : []),
+    readText(join(dir, "script.md")) ?? "",
+  ]);
+}
+
+/* --- on publish -------------------------------------------------------------------------
+   publish.mjs calls `published` right after the Reel (or the carousel) goes up. An enabled rule already applies to it
+   (the id comes from publication.json). With omnichat.instagram.enable_on_publish, the permanent approval
+   to reply without the enable click (like publish.auto.approved), one not yet enabled enables now
+   (the decision is the core's publishedPlan). */
+const realPath = p => {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+};
+const triggerLabel = r =>
+  r.any_comment ? "qualquer comentário" : (r.keywords ?? []).map(p => `"${p}"`).join(", ") || "sem palavra";
+
+function published(dir) {
+  /* the agent only checks videos in this project's videos/ (and each one's carousel) */
+  const content = isCarousel(dir) ? dirname(dir) : dir;
+  if (realPath(dirname(content)) !== realPath(join(ROOT, "videos"))) return;
+  const file = ruleFile(dir);
+  const all = readJson(file) ?? {};
+  const agentHint = () => {
+    if (!cloudOwns() && !agentStatus().loaded)
+      console.log(
+        "aviso: omnichat: o agente está desligado e nada é respondido sozinho: node tools/omnichat.mjs agent install",
+      );
+  };
+  const plan = publishedPlan({
+    rule: all.instagram ?? null,
+    enableOnPublish: !!C.enable_on_publish,
+    keyword: () => narrationKeyword(dir),
+    link: () => videoLink(dir),
+    now: Date.now(),
+    C,
+  });
+  /* --plan: the rule that would be live on the Reel, without writing (the cloud schedule takes it along
+     and turns it on the moment the Reel goes up) */
+  if (has("plan")) {
+    console.log(JSON.stringify({ kind: plan.kind, rule: "rule" in plan && plan.kind !== "draft" ? plan.rule : null }));
+    return;
+  }
+  if (plan.kind === "already_enabled") {
+    /* enabled before the Reel had an id here (the cloud schedule's result arrives later): the cloud only
+       gets the rule now that the id is in publication.json */
+    syncRule(dir);
+    console.log(
+      `omnichat: ligado (${triggerLabel(plan.rule)}): responde n${thePost(dir).slice(1)} a partir da próxima passada`,
+    );
+    agentHint();
+    return;
+  }
+  if (plan.kind === "off") return;
+  if (plan.kind === "disabled_by_user") {
+    console.log(`omnichat: desligado por você n${isCarousel(dir) ? "este carrossel" : "este vídeo"}; fica desligado`);
+    return;
+  }
+  if (plan.kind === "any_comment") {
+    console.log(
+      `omnichat: a regra dispara com qualquer comentário e não liga sozinha: node tools/omnichat.mjs enable ${relativePath(dir)} --confirm`,
+    );
+    return;
+  }
+  if (plan.kind === "no_keyword") {
+    console.log(
+      `omnichat: ${isCarousel(dir) ? "o roteiro do carrossel" : "a narração"} não pede comentário ("comenta X que eu te mando…"): nada para ligar`,
+    );
+    return;
+  }
+  if (plan.born)
+    console.log(
+      `omnichat: termo "${plan.born.keyword}", do pedido ${isCarousel(dir) ? "do carrossel" : "da narração"}${plan.born.found ? `; link achado ${plan.born.found.found_in}` : ""}`,
+    );
+  all.instagram = plan.rule;
+  writeJson(file, all);
+  syncRule(dir);
+  if (plan.kind === "draft") {
+    console.log(
+      `omnichat: a regra ficou gravada, desligada; falta para ligar (etapa Publicar ou página Omnichat):\n  ${plan.problems.join("\n  ")}`,
+    );
+    return;
+  }
+  console.log("omnichat: ligado ao publicar (omnichat.instagram.enable_on_publish)");
+  describe(dir, all.instagram);
+  agentHint();
+}
+
+const alive = pid => {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+};
+
+/* one pass at a time: the agent every minute and someone in the terminal don't reply to the same comment twice */
+function lock() {
+  mkdirSync(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 run(only) {
+  const dryRun = has("dry-run");
+  /* the cloud answers: this machine would answer the same comments twice */
+  if (cloudOwns()) {
+    if (only && dryRun) {
+      const media = mediaOf(only);
+      if (!media) fail(`${thePost(only)} ainda não foi publicado`);
+      const out = await cloudApi("POST", `/api/posts/${media}/run`, { dry_run: true });
+      for (const l of out.log ?? []) console.log(l);
+      if (!out.ran && out.reason) console.log(out.reason);
+    } else if (only) console.log("a cloud responde este post (cloud.omnichat): nada roda aqui");
+    return;
+  }
+  const dirs = (only ? [only] : videosWithRule()).filter(p => (dryRun ? !!ruleOf(p) : ruleOf(p)?.enabled));
+  if (only && !dirs.length)
+    fail(
+      dryRun
+        ? `${thisTarget(only)} não tem regra`
+        : `a regra d${thisTarget(only)} está desligada (--dry-run para ver o que faria)`,
+    );
+  if (!dirs.length) return;
+  const pause = readJson(PAUSE_FILE);
+  if (!dryRun && isPaused(pause, Date.now())) {
+    if (only) console.log(`em pausa até ${dayTime(pause.until)}: ${pause.reason}`);
+    return;
+  }
+  const release = dryRun ? () => {} : lock();
+  if (!release) {
+    if (only) console.log("outra passada está rodando");
+    return;
+  }
+  try {
+    const { token, id } = await instagramToken();
+    /* the account name (to skip its own comments) is only fetched if some post is read */
+    let username;
+    const account = {
+      client: igClient(token),
+      id,
+      username: async () => (username ??= (await instagramAccount(token)).username?.toLowerCase() ?? ""),
+    };
+    for (const dir of dirs) {
+      try {
+        await runTarget(dir, account, dryRun);
+      } catch (e) {
+        if (e instanceof PauseError) {
+          const p = pauseFor(e.message, Date.now(), C);
+          writeJson(PAUSE_FILE, p);
+          console.log(`${nowIso()} pausa até ${dayTime(p.until)}: ${e.message}`);
+          return;
+        }
+        console.log(`${nowIso()} ${nameOf(dir)}: ${e.message}`);
+      }
+    }
+  } finally {
+    release();
+  }
+}
+
+/* --- log and status ---------------------------------------------------------------------- */
+const recordItems = dir => coreRecordItems(readJson(recordFile(dir))?.instagram);
+
+async function showLog(dir) {
+  await pullRecord(dir);
+  const items = recordItems(dir);
+  const rec = readJson(recordFile(dir))?.instagram ?? null;
+  if (has("json")) {
+    console.log(
+      JSON.stringify({
+        totals: totals(items),
+        checked_at: rec?.checked_at ?? null,
+        warning: rec?.warning ?? null,
+        items,
+      }),
+    );
+    return;
+  }
+  const t = totals(items);
+  console.log(
+    `${nameOf(dir)}: ${t.triggers} disparo(s), ${t.dms} DM, ${t.public_replies} pública(s), ${t.queued} na fila, ${t.uncertain ? `${t.uncertain} em dúvida, ` : ""}${t.failures} falha(s)${rec?.checked_at ? ` · conferido ${dayTime(rec.checked_at)}` : ""}`,
+  );
+  if (rec?.warning) console.log(`aviso: ${rec.warning}`);
+  for (const c of items) {
+    const state =
+      c.state === "done"
+        ? `DM ✓${c.public_reply?.at ? " · pública ✓" : ""}`
+        : c.state === "failed"
+          ? `falhou: ${c.error ?? ""}`
+          : c.state === "retry"
+            ? `tentando de novo: ${c.error ?? ""}`
+            : c.state === "skipped"
+              ? `pulado: ${c.reason}`
+              : c.state === "uncertain"
+                ? "em dúvida: o Claude ainda não leu"
+                : "na fila";
+    console.log(`${dayTime(c.commented_at)}  @${(c.username ?? "?").padEnd(20)} "${c.text.slice(0, 40)}"  ${state}`);
+  }
+}
+
+async function status() {
+  const s = { agent: agentStatus(), pause: null, account: null, comments: null, rules: [] };
+  const pause = readJson(PAUSE_FILE);
+  if (isPaused(pause, Date.now())) s.pause = pause;
+  if (cloudOwns()) {
+    await Promise.all(videosWithRule().map(d => pullRecord(d).catch(() => {})));
+    /* the cloud answers: its pause and its token are the ones that count */
+    try {
+      const c = await cloudApi("GET", "/api/status");
+      s.cloud = { ready: true, active: !!c.active, expires: c.account?.expires ?? null };
+      if (!c.active) s.cloud.reason = "a cloud não está respondendo (cloud push)";
+      if (c.account?.paused_until && Date.parse(c.account.paused_until) > Date.now())
+        s.pause = { until: c.account.paused_until, reason: c.account.pause_reason ?? "", at: null };
+      else s.pause = null;
+    } catch (e) {
+      s.cloud = { ready: false, reason: `não deu para falar com a cloud: ${e.message}` };
+    }
+  }
+  /* the hosted studio: whether this Mac is paired and connected to it */
+  const runner = await runnerStatus();
+  if (runner.configured)
+    s.studio = { url: runner.url, paired: runner.paired, name: runner.name, online: runner.online };
+  for (const dir of videosWithRule()) {
+    const r = ruleOf(dir);
+    if (!r) continue;
+    const rec = readJson(recordFile(dir))?.instagram;
+    s.rules.push({
+      slug: nameOf(dir),
+      dir,
+      carousel: isCarousel(dir),
+      enabled: !!r.enabled,
+      published: !!readJson(join(dir, "publication.json"))?.instagram?.id,
+      keywords: r.any_comment ? null : r.keywords,
+      totals: totals(recordItems(dir)),
+      checked_at: rec?.checked_at ?? null,
+      warning: rec?.warning ?? null,
+    });
+  }
+  /* the comments permission: on a post with comments, the list comes back empty without it */
+  try {
+    const { token } = await instagramToken();
+    const c = await instagramAccount(token);
+    s.account = { ready: true, username: `@${c.username}`, expires: env("INSTAGRAM_TOKEN_EXPIRES") || null };
+    const client = igClient(token);
+    const j = await client.recentMedia("id,comments_count", "25");
+    const withComment = (j.data ?? []).find(m => m.comments_count > 0);
+    if (!withComment) s.comments = { ready: null, reason: "nenhum post recente com comentário para conferir" };
+    else {
+      const cs = await client.commentIds(withComment.id);
+      s.comments = cs.data?.length
+        ? { ready: true }
+        : {
+            ready: false,
+            reason:
+              "a API devolve a lista de comentários vazia: o app precisa estar publicado (Live, em developers.facebook.com → Publicar) e o token com instagram_business_manage_comments e instagram_business_manage_messages",
+          };
+    }
+  } catch (e) {
+    if (!s.account) s.account = { ready: false, reason: e.message };
+    else s.comments = { ready: false, reason: e.message };
+  }
+  if (has("json")) {
+    console.log(JSON.stringify(s));
+    return;
+  }
+  console.log(`${s.account.ready ? "✓" : "·"} instagram: ${s.account.ready ? s.account.username : s.account.reason}`);
+  if (s.comments)
+    console.log(
+      `${s.comments.ready ? "✓" : "·"} comentários: ${s.comments.ready ? "lidos pela API" : s.comments.reason}`,
+    );
+  console.log("  DM: a permissão de mensagens só se confere no primeiro envio");
+  console.log(
+    `  agente: ${s.agent.loaded ? "ligado, confere a cada minuto" : "desligado (node tools/omnichat.mjs agent install)"}`,
+  );
+  if (s.studio)
+    console.log(
+      `  studio hospedado: ${s.studio.paired ? `este Mac (${s.studio.name}) ${s.studio.online ? "atende por ele agora" : "não está conectado: o studio hospedado mostra a última cópia (node tools/runner.mjs status)"}` : "este Mac não está pareado (node tools/runner.mjs login)"}`,
+    );
+  if (s.pause) console.log(`  em pausa até ${dayTime(s.pause.until)}: ${s.pause.reason}`);
+  if (!s.rules.length) console.log("  nenhum vídeo com regra");
+  for (const r of s.rules) {
+    console.log(
+      `  ${r.enabled ? "ligada   " : "desligada"} ${r.slug}${r.published ? "" : " (post ainda não publicado)"} · ${r.totals.dms} DM${r.warning ? ` · ${r.warning}` : ""}`,
+    );
+  }
+}
+
+/* --- the cloud: the Worker in cloud/omnichat answers instead of this machine -------------------
+   cloud.url in the config and OMNICHAT_CLOUD_SECRET in the .env (the Worker's SYNC_SECRET).
+   `cloud push` sends what the Worker needs: the config (the default texts and limits), the Instagram
+   account (token sealed there) and each published post's rule; with --records, the local record too,
+   once, so whoever already got the DM never gets it again. While cloud.omnichat is false nothing
+   else changes. With owns: true the cloud is the one answering: every saved rule goes up on its own,
+   the record is read from there (and mirrored into omnichat-record.json for the studio), the manual
+   send goes through it, and the local agent and webhook stop answering. */
+const cloudReady = () => cloudSettings().ready;
+const cloudOwns = () => cloudSettings().owns.omnichat;
+const CLOUD = {
+  get url() {
+    return cloudSettings().url;
+  },
+};
+
+/* The rule goes to the cloud. A video the cloud schedule publishes: into its job, which turns it on the
+   moment the Reel is up (or at once if it already is, even before this machine reads the Reel's id).
+   Otherwise onto the post, by the id in publication.json. False: nothing in the cloud to put it on yet. */
+async function pushRule(dir) {
+  const rule = ruleOf(dir);
+  if (!rule) return false;
+  if (!isCarousel(dir) && readJson(join(dir, "publication.json"))?.schedule?.cloud) {
+    const r = await cloudApi("PUT", `/api/schedule/${basename(dir)}/rule`, { rule });
+    if (r.found) return true;
+  }
+  const media = mediaOf(dir);
+  if (!media) return false;
+  const pub = readJson(join(dir, "publication.json"))?.instagram ?? {};
+  await cloudApi("PUT", `/api/posts/${media}`, {
+    name: nameOf(dir),
+    post_url: pub.url ?? null,
+    published_at: pub.published_at ?? null,
+    rule,
+  });
+  return true;
+}
+
+/* a saved rule goes up when the cloud answers (the CLI waits for it before exiting: flushCloud) */
+const pendingCloud = [];
+function syncRule(dir) {
+  if (!cloudOwns()) return;
+  pendingCloud.push(
+    pushRule(dir)
+      .then(sent => {
+        if (!sent) console.log(`omnichat: a regra de ${nameOf(dir)} vai para a cloud quando ${thePost(dir)} subir`);
+      })
+      .catch(e => console.error(`aviso: a cloud não recebeu a regra de ${nameOf(dir)}: ${e.message}`)),
+  );
+}
+const flushCloud = () => Promise.all(pendingCloud.splice(0));
+
+/* the cloud's record mirrored into omnichat-record.json: the studio and the log read the file */
+async function pullRecord(dir) {
+  if (!cloudOwns()) return;
+  const media = mediaOf(dir);
+  if (!media) return;
+  try {
+    const out = await cloudApi("GET", `/api/posts/${media}`);
+    const file = recordFile(dir);
+    const all = readJson(file) ?? {};
+    /* only a change is written: the write is a studio notice, and the notice makes the page read (and
+       pull) again, so an unchanged record written anyway loops against the cloud */
+    if (JSON.stringify(all.instagram ?? null) === JSON.stringify(out.record ?? null)) return;
+    all.instagram = out.record;
+    delete all.cloud;
+    writeJson(file, all);
+  } catch (e) {
+    if (e.status !== 404) console.error(`aviso: não deu para ler o registro na cloud: ${e.message}`);
+  }
+}
+
+/* the cloud's health for the studio: answering, its pause and when the token expires */
+async function cloudHealth() {
+  try {
+    const c = await cloudApi("GET", "/api/status");
+    const paused = c.account?.paused_until && Date.parse(c.account.paused_until) > Date.now();
+    return {
+      owns: true,
+      ready: true,
+      active: !!c.active,
+      expires: c.account?.expires ?? null,
+      pause: paused ? { until: c.account.paused_until, reason: c.account.pause_reason ?? "" } : null,
+    };
+  } catch (e) {
+    return { owns: true, ready: false, reason: e.message };
+  }
+}
+
+async function cloudCmd(sub) {
+  if (sub === "status") {
+    console.log(
+      `${CLOUD.url ? "✓" : "·"} cloud.url${CLOUD.url ? `: ${CLOUD.url}` : " (falta no omnivideo.config.json)"}`,
+    );
+    console.log(`${env("OMNICHAT_CLOUD_SECRET") ? "✓" : "·"} OMNICHAT_CLOUD_SECRET no .env`);
+    console.log(`  quem responde: ${cloudOwns() ? "a cloud (cloud.omnichat)" : "esta máquina"}`);
+    if (!cloudReady()) return;
+    const s = await cloudApi("GET", "/api/status");
+    console.log(
+      `${s.active === cloudOwns() ? "✓" : "·"} a cloud ${s.active ? "responde" : "não responde"}${s.active !== cloudOwns() ? " (diferente do config: cloud push)" : ""}`,
+    );
+    console.log(
+      `${s.account ? "✓" : "·"} conta na cloud: ${s.account ? `@${s.account.username ?? s.account.id}${s.account.paused_until && Date.parse(s.account.paused_until) > Date.now() ? ` (em pausa: ${s.account.pause_reason})` : ""}` : "nenhuma (cloud push)"}`,
+    );
+    const there = new Map((s.posts ?? []).map(p => [p.media_id, p]));
+    for (const dir of videosWithRule()) {
+      const media = mediaOf(dir);
+      if (!media) continue;
+      const p = there.get(media);
+      const local = !!ruleOf(dir)?.enabled;
+      console.log(
+        `  ${p ? (p.enabled ? "ligada   " : "desligada") : "fora     "} ${nameOf(dir)}${p && p.enabled !== local ? ` (aqui está ${local ? "ligada" : "desligada"}: cloud push)` : ""}`,
+      );
+    }
+    return;
+  }
+  if (sub === "push") {
+    const only = args[2] && !args[2].startsWith("--") ? resolve(args[2]) : null;
+    await cloudApi("PUT", "/api/config", C);
+    /* the cloud answers only with cloud.omnichat: never both */
+    await cloudApi("PUT", "/api/active", { active: cloudOwns() });
+    const { token, id } = await instagramToken();
+    const acc = await instagramAccount(token);
+    await cloudApi("PUT", "/api/account", {
+      id,
+      username: acc.username ?? null,
+      token,
+      expires: env("INSTAGRAM_TOKEN_EXPIRES") || null,
+    });
+    console.log(`config e conta @${acc.username} na cloud`);
+    for (const dir of only ? [only] : videosWithRule()) {
+      if (!(await pushRule(dir))) {
+        if (only) console.log(`${nameOf(dir)}: sem regra ou ainda não publicado`);
+        continue;
+      }
+      let rec = "";
+      if (has("records")) {
+        const record = readJson(recordFile(dir))?.instagram;
+        if (record) {
+          try {
+            await cloudApi("PUT", `/api/posts/${mediaOf(dir)}/record`, { record, force: has("force") });
+            rec = ", com o registro";
+          } catch (e) {
+            rec =
+              e.status === 409 ? ", registro já estava lá (--force sobrescreve)" : `, registro não foi: ${e.message}`;
+          }
+        }
+      }
+      console.log(`  ${nameOf(dir)}: regra ${ruleOf(dir)?.enabled ? "ligada" : "desligada"}${rec}`);
+    }
+    console.log(
+      cloudOwns()
+        ? "a cloud responde a partir de agora (cloud.omnichat)"
+        : "a cloud recebeu, mas quem responde ainda é esta máquina (cloud.omnichat: true para virar)",
+    );
+    return;
+  }
+  if (sub === "pull" && args[2] && existsSync(join(resolve(args[2]), "publication.json"))) {
+    if (!cloudOwns()) fail("só com cloud.omnichat: enquanto esta máquina responde, o registro daqui é o que vale");
+    await pullRecord(resolve(args[2]));
+    console.log(`registro de ${nameOf(resolve(args[2]))} lido da cloud`);
+    return;
+  }
+  fail("cloud status | push [videos/<slug>] [--records] [--force] | pull videos/<slug>");
+}
+
+/* --- the messaging webhook: the button's tap and the follow gate ------------------------------
+   The comment's DM opens with a button (rule.button / rule.require_follow). The tap reaches here as a
+   `messaging_postbacks` event; handleTap (tools/lib/omnichat/gate.mjs) checks the criterion and sends the
+   link, or asks to follow. Meta needs a public HTTPS callback URL: `serve` listens on this machine and a
+   tunnel (cloudflared) exposes it while the Mac is awake. A webhook handled elsewhere (a cloud function)
+   uses the same handleWebhook. The record is written under the pass lock, so the agent and the tap
+   don't overwrite each other. */
+const WEBHOOK_PORT = 5434;
+const gatedRules = () => videosWithRule().filter(d => gateOn(ruleOf(d) ?? {}));
+
+async function lockWait(ms) {
+  for (let t = 0; t <= ms; t += 500) {
+    const release = lock();
+    if (release) return release;
+    await sleep(500);
+  }
+  return null;
+}
+
+/* the target of a post by its media id, for a tap (the rule may be off: whoever got the button still gets the link) */
+function targetForMedia(media) {
+  const dir = videosWithRule().find(d => mediaOf(d) === media);
+  if (!dir) return null;
+  return {
+    name: nameOf(dir),
+    post: postOf(dir),
+    withRecord: async fn => {
+      const release = await lockWait(60_000);
+      if (!release) throw new Error("outra passada segurou o registro por mais de 1 min; o Meta repete o evento");
+      try {
+        const all = readJson(recordFile(dir)) ?? {};
+        all.instagram ??= { media, comments: {} };
+        if (await fn({ rule: ruleOf(dir), record: all.instagram })) writeJson(recordFile(dir), all);
+      } finally {
+        release();
+      }
+    },
+  };
+}
+
+async function webhook(sub) {
+  const secret = env("INSTAGRAM_APP_SECRET");
+  const verifyToken = env("INSTAGRAM_WEBHOOK_VERIFY_TOKEN");
+  const port = +(option("port") ?? WEBHOOK_PORT);
+  if (sub === "setup") {
+    let token = verifyToken;
+    if (!token) {
+      token = randomBytes(16).toString("hex");
+      writeEnv({ INSTAGRAM_WEBHOOK_VERIFY_TOKEN: token });
+    }
+    console.log(
+      `${secret ? "✓" : "·"} INSTAGRAM_APP_SECRET no .env${secret ? "" : " (falta: o segredo do app Instagram, em API setup with Instagram login → App secret)"}`,
+    );
+    console.log("✓ INSTAGRAM_WEBHOOK_VERIFY_TOKEN no .env");
+    console.log(`
+Faltam estes passos, uma vez só:
+  1. Expor a porta ${port}: node tools/omnichat.mjs webhook serve   e, em outro terminal,
+     cloudflared tunnel --url http://127.0.0.1:${port}   (anote a URL https://….trycloudflare.com)
+  2. developers.facebook.com/apps → seu app → Instagram → API setup with Instagram login → Configure webhooks:
+       Callback URL:  <a URL do túnel>/webhook
+       Verify token:  ${token}
+     e ligue os campos messages e messaging_postbacks.
+  3. node tools/omnichat.mjs webhook subscribe   (inscreve a conta nesses campos)
+  4. O app precisa estar Live, com Advanced Access em instagram_business_manage_messages para quem não tem papel no app.`);
+    return;
+  }
+  if (sub === "subscribe") {
+    const { token, id } = await instagramToken();
+    await igClient(token).subscribeWebhook(id, WEBHOOK_FIELDS);
+    console.log(`conta inscrita em: ${WEBHOOK_FIELDS.join(", ")}`);
+    return;
+  }
+  if (sub === "status") {
+    const gated = gatedRules();
+    console.log(`${secret ? "✓" : "·"} INSTAGRAM_APP_SECRET`);
+    console.log(
+      `${verifyToken ? "✓" : "·"} INSTAGRAM_WEBHOOK_VERIFY_TOKEN${verifyToken ? "" : " (webhook setup cria)"}`,
+    );
+    try {
+      const { token, id } = await instagramToken();
+      const fields = await igClient(token).webhookFields(id);
+      const missing = WEBHOOK_FIELDS.filter(f => !fields.includes(f));
+      console.log(
+        `${missing.length ? "·" : "✓"} conta inscrita em: ${fields.join(", ") || "nada"}${missing.length ? ` (falta ${missing.join(", ")}: webhook subscribe)` : ""}`,
+      );
+    } catch (e) {
+      console.log(`· inscrição da conta: ${e.message}`);
+    }
+    console.log(`  regras com botão: ${gated.length ? gated.map(nameOf).join(", ") : "nenhuma"}`);
+    return;
+  }
+  if (sub === "serve") {
+    if (!secret || !verifyToken)
+      fail(
+        "faltam INSTAGRAM_APP_SECRET e INSTAGRAM_WEBHOOK_VERIFY_TOKEN no .env: node tools/omnichat.mjs webhook setup",
+      );
+    const account = async () => {
+      const { token, id } = await instagramToken();
+      return { client: igClient(token), id };
+    };
+    const server = createServer(async (req, res) => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+      if (url.pathname !== "/webhook" && url.pathname !== "/") {
+        res.writeHead(404).end();
+        return;
+      }
+      const chunks = [];
+      for await (const c of req) chunks.push(c);
+      const out = await handleWebhook({
+        method: req.method ?? "GET",
+        query: Object.fromEntries(url.searchParams),
+        raw: Buffer.concat(chunks).toString("utf8"),
+        signature: req.headers["x-hub-signature-256"],
+        secret,
+        verifyToken,
+        resolveTarget: async media => targetForMedia(media),
+        account,
+        C,
+        log,
+        warn: line => console.error(line),
+      });
+      res.writeHead(out.status, { "content-type": "text/plain; charset=utf-8" }).end(out.body);
+    });
+    server.listen(port, "127.0.0.1", () =>
+      console.log(`webhook do omnichat ouvindo em http://127.0.0.1:${port}/webhook (exponha com um túnel HTTPS)`),
+    );
+    await new Promise(() => {});
+  }
+  fail("webhook setup | subscribe | status | serve [--port 5434]");
+}
+
+/* --- the launchd agent ------------------------------------------------------------------
+   Runs `run` every 60 s with the node that installed it. Does not wake the Mac: while asleep,
+   comments wait and are replied to when it wakes, within the 7 days. */
+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_LABEL}`).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;");
+  /* the shell PATH goes along: launchd starts without claude, which reads the context of uncertain comments */
+  const path = [
+    ...new Set([
+      dirname(process.execPath),
+      "/opt/homebrew/bin",
+      "/usr/local/bin",
+      join(homedir(), ".local", "bin"),
+      ...(process.env.PATH ?? "").split(":"),
+      "/usr/bin",
+      "/bin",
+    ]),
+  ]
+    .filter(Boolean)
+    .join(":");
+  mkdirSync(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_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${x(process.execPath)}</string>
+    <string>${x(SELF)}</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>
+`,
+  );
+  launchctl("bootout", `${domain()}/${AGENT_LABEL}`);
+  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()}`);
+  const enabled = videosWithRule().filter(p => ruleOf(p)?.enabled).length;
+  console.log(
+    `agente do omnichat ligado: confere a cada minuto, com o studio aberto ou não (log em .omnichat/omnichat.log)${enabled ? "" : "; nenhuma regra ligada ainda"}`,
+  );
+}
+
+function uninstallAgent() {
+  launchctl("bootout", `${domain()}/${AGENT_LABEL}`);
+  try {
+    unlinkSync(PLIST);
+  } catch {
+    /* was not there */
+  }
+  console.log(
+    "agente do omnichat desligado: os comentários esperam até você ligar de novo (a DM vale até 7 dias depois do comentário)",
+  );
+}
+
+/* ============================================================================
+   CLI only: the studio imports videoLink and narrationKeyword */
+const isMain = isMainModule(import.meta.url);
+if (isMain) {
+  const [cmd, sub] = args;
+  /* target: a video's dir (scenes.json), a content's carousel dir (carousel.json) or an outside post's */
+  const isVideo = p =>
+    p &&
+    !p.startsWith("--") &&
+    (existsSync(join(resolve(p), "scenes.json")) ||
+      isCarousel(resolve(p)) ||
+      (resolve(p).startsWith(POSTS + "/") && existsSync(join(resolve(p), "publication.json"))));
+  try {
+    if (cmd === "status") await status();
+    else if (cmd === "rule" && isVideo(sub)) rule(resolve(sub));
+    else if (cmd === "post") await post(sub);
+    else if (cmd === "enable" && isVideo(sub)) enable(resolve(sub));
+    else if (cmd === "disable" && isVideo(sub)) disable(resolve(sub));
+    else if (cmd === "published" && isVideo(sub)) published(resolve(sub));
+    else if (cmd === "test" && isVideo(sub)) await test(resolve(sub), args[2]);
+    else if (cmd === "retry" && isVideo(sub)) await retry(resolve(sub));
+    else if (cmd === "comments" && isVideo(sub)) await comments(resolve(sub));
+    else if (cmd === "delete" && isVideo(sub))
+      await remove(
+        resolve(sub),
+        args.slice(2).filter(a => !a.startsWith("--")),
+      );
+    else if (cmd === "send" && isVideo(sub))
+      await send(
+        resolve(sub),
+        args.slice(2).filter((a, i, l) => !a.startsWith("--") && l[i - 1] !== "--public-reply"),
+      );
+    else if (cmd === "run") await run(isVideo(sub) ? resolve(sub) : null);
+    else if (cmd === "log" && isVideo(sub)) await showLog(resolve(sub));
+    else if (cmd === "webhook") await webhook(sub);
+    else if (cmd === "cloud") await cloudCmd(sub);
+    else if (cmd === "agent" && (!sub || sub === "--json")) {
+      const a = agentStatus();
+      /* the cloud answering is what the studio shows instead of the local agent */
+      if (cloudOwns()) a.cloud = await cloudHealth();
+      if (has("json")) console.log(JSON.stringify(a));
+      else if (a.cloud)
+        console.log(
+          `quem responde: a cloud${a.cloud.ready ? (a.cloud.active ? "" : " (desligada: cloud push)") : ` (sem resposta: ${a.cloud.reason})`}${a.cloud.pause ? ` · em pausa até ${dayTime(a.cloud.pause.until)}: ${a.cloud.pause.reason}` : ""}`,
+        );
+      else
+        console.log(
+          `agente: ${a.loaded ? "ligado, confere a cada minuto" : "desligado (agent install)"}${a.installed && !a.node_ok ? " · o node do agente sumiu: rode agent install de novo" : ""}`,
+        );
+    } else if (cmd === "agent" && sub === "install") installAgent();
+    else if (cmd === "agent" && sub === "uninstall") uninstallAgent();
+    else {
+      const source = readFileSync(SELF, "utf8").split("\n");
+      console.log(
+        source
+          .slice(
+            1,
+            source.findIndex((l, i) => i > 1 && /^\s*=+\s*\*\/\s*$/.test(l)),
+          )
+          .join("\n"),
+      );
+      process.exit(2);
+    }
+    /* a rule saved while the cloud answers goes up before the CLI exits */
+    await flushCloud();
+  } catch (e) {
+    fail(e.message);
+  }
+}