@crievo/omni 0.0.0-stage → 0.1.0

package/tools/lib/omnichat/pass.mjs

@@ -0,0 +1,393 @@
+/* ============================================================================
+   One omnichat pass on one post: read the new comments, decide who gets the
+   DM (dedupe by comment id, skip the account's own and the ones it already
+   answered by hand), let an optional classifier decide the uncertain ones,
+   then work the queue (DM first; the public reply only once the DM went).
+   Pure: the record comes in and is saved through `save`; the Instagram calls
+   go through an injected client; the classifier is an injected function (the
+   CLI asks Claude; the cloud runs without one and leaves uncertain comments).
+   ============================================================================ */
+
+import { DAY, withDefaults } from "../http.mjs";
+import { CURSOR_MARGIN, DM_DEADLINE, MAX_PAGES } from "./config.mjs";
+import { errorType, PauseError } from "./errors.mjs";
+import { normalize, triggers } from "./match.mjs";
+import { sendOpener } from "./gate.mjs";
+import { buttonLabel, deliveryMessage, deliveryPreview, gateOn, openingText, publicReplyText } from "./text.mjs";
+
+/** @typedef {import("../http.mjs").Deps} Deps */
+/** @typedef {import("./match.mjs").Rule} Rule */
+/** @typedef {import("./config.mjs").OmnichatConfig} OmnichatConfig */
+/** @typedef {import("../platforms/instagram.mjs").InstagramClient} InstagramClient */
+
+/**
+ * @typedef {object} CommentRecord
+ * @property {string | null} username
+ * @property {string} text
+ * @property {string} commented_at
+ * @property {"queued" | "retry" | "uncertain" | "done" | "failed" | "skipped"} state
+ * @property {number} [attempts]
+ * @property {number} [pauses]
+ * @property {number} [uncertain_count]
+ * @property {string} [reason]
+ * @property {string} [error]
+ * @property {string} [context]
+ * @property {string} [account_reply]
+ * @property {boolean} [manual]
+ * @property {string} [manual_at]
+ * @property {import("./gate.mjs").GateRecord} [gate] the button and follow gate: where the person is after the opener
+ * @property {{ at?: string, id?: string | null, text?: string, error?: string, failed_at?: string }} [dm] `text`: what the DM said (the opener, when the rule has a button)
+ * @property {{ at?: string, id?: string | null, text?: string, manual?: boolean, error?: string, failed_at?: string }} [public_reply]
+ */
+
+/**
+ * @typedef {object} PostRecord omnichat-record.json `instagram`
+ * @property {string} [media]
+ * @property {Record<string, CommentRecord>} comments
+ * @property {string | null} [seen_until]
+ * @property {number | null} [count]
+ * @property {string} [count_lag_since] when the count moved but the comment list did not (see runPass)
+ * @property {string | null} [next_check]
+ * @property {{ url: string, limit: number } | null} [resume]
+ * @property {string} [rule_seen]
+ * @property {string} [checked_at]
+ * @property {string} [warning]
+ */
+
+/**
+ * The classifier for uncertain comments: { id: true|false }, or null when it could not answer.
+ * @typedef {(items: Array<[string, CommentRecord]>) => Promise<Record<string, boolean> | null>} Classify
+ */
+
+/** How long a moved count with an unchanged comment list is treated as the API lagging. */
+const COUNT_LAG_MS = 10 * 60_000;
+
+/** Pass identity for the account: the token client, the user id and its (lazily fetched) username. */
+/** @typedef {{ client: InstagramClient, id: string, username: () => Promise<string> }} Account */
+
+/**
+ * Minutes between checks, by the post's age.
+ * @param {string | number} publishedAt @param {number} now @param {OmnichatConfig} C
+ */
+export function intervalMin(publishedAt, now, C) {
+  const age = now - Date.parse(/** @type {string} */ (publishedAt));
+  if (age < 2 * DAY) return C.interval_min.first_48h;
+  if (age < 7 * DAY) return C.interval_min.first_week;
+  return C.interval_min.after;
+}
+
+/**
+ * The comments waiting for a reply.
+ * @param {{ comments?: Record<string, CommentRecord> }} r
+ */
+export const pendingOf = r =>
+  Object.entries(r.comments ?? {}).filter(([, c]) => c.state === "queued" || c.state === "retry");
+
+/** @param {any} c */
+export const authorOf = c => (c.from?.username ?? c.username ?? "").toLowerCase();
+
+/**
+ * The account's manual replies to each comment: the one nested in it and a loose comment with @someone.
+ * @param {any[]} read @param {string} us the account's username, lower-case
+ * @returns {(c: any) => any[]}
+ */
+export function accountReplies(read, us) {
+  const mentions = new Map();
+  for (const c of read.filter(c => authorOf(c) === us)) {
+    for (const [, u] of String(c.text ?? "").matchAll(/@([\w.]+)/g)) {
+      const k = u.toLowerCase().replace(/\.$/, "");
+      mentions.set(k, [...(mentions.get(k) ?? []), c]);
+    }
+  }
+  return c => [
+    ...(c.replies?.data ?? []).filter((/** @type {any} */ x) => x.username?.toLowerCase() === us),
+    ...(mentions.get(authorOf(c)) ?? []).filter((/** @type {any} */ x) => x.timestamp >= c.timestamp),
+  ];
+}
+
+/**
+ * Turns freshly read comments into record entries. Dedupe: a comment already in the record
+ * is not touched (except a skipped one, reread in case the rule changed), nor is the
+ * account's own. Mutates `r.comments`.
+ * @param {PostRecord} r @param {any[]} read @param {Rule} rule @param {string} us @param {OmnichatConfig} C
+ * @returns {number} how many new comments trigger
+ */
+export function ingest(r, read, rule, us, C) {
+  const replies = accountReplies(read, us);
+  let fresh = 0;
+  for (const c of read) {
+    const username = c.from?.username ?? c.username ?? null;
+    if ((r.comments[c.id] && r.comments[c.id].state !== "skipped") || authorOf(c) === us) continue;
+    const trigger = triggers(rule, c.text, C);
+    if (!trigger) continue;
+    /* already replied by hand: skip, unless the rule says send (and, with already_replied_if,
+       only when that reply says one of the snippets) */
+    const ours = replies(c);
+    if (ours.length) {
+      const ifSays = (rule.already_replied_if ?? []).map(normalize).filter(Boolean);
+      const send =
+        rule.already_replied === "send" &&
+        (!ifSays.length || ours.some(x => ifSays.some(t => ` ${normalize(x.text)} `.includes(` ${t} `))));
+      if (!send) {
+        r.comments[c.id] = {
+          username,
+          text: c.text ?? "",
+          commented_at: c.timestamp,
+          state: "skipped",
+          reason: "já respondido pela conta",
+          account_reply: ours[0].text ?? "",
+        };
+        continue;
+      }
+    }
+    r.comments[c.id] = {
+      username,
+      text: c.text ?? "",
+      commented_at: c.timestamp,
+      state: trigger === "yes" ? "queued" : "uncertain",
+      attempts: 0,
+    };
+    fresh++;
+  }
+  return fresh;
+}
+
+/**
+ * Applies the classifier's answer to the uncertain comments; no answer counts toward
+ * `attempts`, after which the comment is skipped. Mutates the comments.
+ * @param {Array<[string, CommentRecord]>} uncertain @param {Record<string, boolean> | null} resp @param {OmnichatConfig} C
+ */
+export function applyClassification(uncertain, resp, C) {
+  for (const [cid, c] of uncertain) {
+    if (resp && typeof resp[cid] === "boolean") {
+      Object.assign(
+        c,
+        resp[cid]
+          ? { state: "queued", context: "o Claude leu como pedido" }
+          : { state: "skipped", reason: "não pede o envio (o Claude leu pelo contexto)" },
+      );
+    } else {
+      c.uncertain_count = (c.uncertain_count ?? 0) + 1;
+      if (c.uncertain_count >= C.attempts)
+        Object.assign(c, { state: "skipped", reason: "pedido no meio de uma frase e o Claude não respondeu" });
+    }
+  }
+}
+
+/**
+ * Replies to one comment: the DM (once: a comment with `dm.at` never gets a second one),
+ * then the public reply. Rate limit, block and token errors throw PauseError (the account
+ * pauses); the rest marks the comment retry or failed. Mutates `c`.
+ * With a button on the rule, the DM is the opener (the link goes out when the person taps, see gate.mjs).
+ * @param {{ cid: string, c: CommentRecord, rule: Rule, account: { client: InstagramClient, id: string },
+ *   media: string, name: string, post: string | null, C: OmnichatConfig } & Deps} p
+ */
+export async function reply({ cid, c, rule, account, media, name, post, C, ...deps }) {
+  const d = withDefaults(deps);
+  const iso = () => new Date(d.now()).toISOString();
+  const who = `@${c.username ?? "?"}`;
+  c.attempts = (c.attempts ?? 0) + 1;
+  /** @param {"dm" | "public_reply"} step @param {any} e */
+  const failStep = (step, e) => {
+    const type = errorType(e);
+    c.error = e.message;
+    c[step] = { error: e.message, failed_at: iso() };
+    if (type === "rate_limit" || type === "blocked" || type === "account") {
+      c.attempts = /** @type {number} */ (c.attempts) - 1;
+      c.pauses = (c.pauses ?? 0) + 1;
+      if (type !== "account" || c.pauses < C.attempts) {
+        c.state = "retry";
+        throw new PauseError(
+          `${{ blocked: "a Meta bloqueou a ação", rate_limit: "limite de taxa da Meta", account: "token ou permissão" }[type]}: ${e.message}`,
+        );
+      }
+      c.state = "failed";
+      d.log(
+        `${iso()} ${name}: ${step === "dm" ? "DM" : "resposta pública"} para ${who} falhou ${c.pauses} vezes, desisti: ${e.message}`,
+      );
+      return;
+    }
+    c.state = type === "transient" && /** @type {number} */ (c.attempts) < C.attempts ? "retry" : "failed";
+    d.log(
+      `${iso()} ${name}: ${step === "dm" ? "DM" : "resposta pública"} para ${who} ${c.state === "retry" ? "falhou, tento de novo" : "falhou"}: ${e.message}`,
+    );
+  };
+
+  if (!c.dm?.at) {
+    try {
+      if (gateOn(rule)) {
+        const { id, via } = await sendOpener({
+          client: account.client,
+          userId: account.id,
+          media,
+          commentId: cid,
+          rule,
+          username: c.username,
+          C,
+        });
+        c.dm = { at: iso(), id, text: openingText(rule, c.username, C) };
+        c.gate = { state: "awaiting_tap", via, at: iso() };
+      } else {
+        const { id } = await account.client.privateReply(account.id, cid, deliveryMessage(rule, c.username, post, C));
+        c.dm = { at: iso(), id, text: deliveryPreview(rule, c.username, post, C) };
+      }
+    } catch (e) {
+      failStep("dm", e);
+      return;
+    }
+  }
+  const publicText = c.public_reply?.at ? null : publicReplyText(rule, c.username, C, d.random);
+  if (publicText) {
+    try {
+      const { id } = await account.client.publicReply(cid, publicText);
+      c.public_reply = { at: iso(), id, text: publicText };
+    } catch (e) {
+      failStep("public_reply", e);
+      /* the DM already went: a public reply that won't go for good does not hold the comment in the queue */
+      if (c.state === "retry") return;
+    }
+  }
+  c.state = "done";
+  delete c.error;
+  d.log(`${iso()} ${name}: ${who} respondido (DM${c.public_reply?.at ? " e pública" : ""})`);
+}
+
+/**
+ * One pass on one published post. Throws PauseError when the account must pause.
+ * @param {{ rule: Rule, media: string, stored?: Partial<PostRecord> | null, account: Account, name: string,
+ *   postFallback: string | null, dryRun?: boolean, force?: boolean, maxPages?: number, classify?: Classify,
+ *   save: (r: PostRecord) => void | Promise<void>, C: OmnichatConfig } & Deps} p
+ *   `stored` is omnichat-record.json's `instagram`; `save` persists it (never called on a dry run; awaited, so a
+ *   database write finishes before the next DM goes). `force` reads now even before next_check: a webhook said
+ *   there is a new comment. `maxPages` caps the comment pages read in this pass (a cloud function has a
+ *   budget of subrequests); the rest resumes on the next one
+ * @returns {Promise<PostRecord>}
+ */
+export async function runPass({
+  rule,
+  media,
+  stored,
+  account,
+  name,
+  postFallback,
+  dryRun = false,
+  force = false,
+  maxPages = MAX_PAGES,
+  classify,
+  save,
+  C,
+  ...deps
+}) {
+  const d = withDefaults(deps);
+  const iso = () => new Date(d.now()).toISOString();
+  /** @type {PostRecord} */
+  let r = /** @type {any} */ (stored ?? {});
+  /* published again (--again): another post, read from scratch; the already replied stay */
+  if (r.media && r.media !== media) r = /** @type {any} */ ({ comments: r.comments });
+  r.media = media;
+  r.comments ??= {};
+  /* rule changed (another keyword, any comment): rereads the 7 days with the new rule */
+  if (r.rule_seen !== rule.updated_at)
+    Object.assign(r, { seen_until: null, count: null, next_check: null, resume: null, rule_seen: rule.updated_at });
+  const persist = async () => {
+    if (!dryRun) await save(r);
+  };
+  const now = d.now();
+  /* without a classifier, uncertain comments wait for a pass that has one: they don't force a read */
+  const waitingClassifier = !!classify && Object.values(r.comments).some(c => c.state === "uncertain");
+  if (
+    !dryRun &&
+    !force &&
+    r.next_check &&
+    Date.parse(r.next_check) > now &&
+    !r.resume &&
+    !pendingOf(r).length &&
+    !waitingClassifier
+  )
+    return r;
+
+  const m = await account.client.media(media, "comments_count,timestamp,permalink");
+  const post = m.permalink ?? postFallback;
+  r.checked_at = iso();
+  r.next_check = new Date(now + intervalMin(m.timestamp ?? now, now, C) * 60_000).toISOString();
+
+  /* 1. new comments, newest to oldest, down to the last seen one */
+  /* the count alone misses a comment that came while another was deleted (the total stays the same):
+     a forced pass (a webhook said there is a new one) always reads */
+  if (force || m.comments_count !== r.count || !r.seen_until || r.resume || dryRun) {
+    /* a pass that stopped midway (more than MAX_PAGES pages) continues where it stopped, with the
+       same limit, instead of moving the cursor over what was left out */
+    const resuming = !dryRun && r.resume ? r.resume : null;
+    const limit =
+      resuming?.limit ?? Math.max(r.seen_until ? Date.parse(r.seen_until) - CURSOR_MARGIN : 0, now - DM_DEADLINE);
+    const { read, next } = await account.client.comments(media, limit, resuming?.url, maxPages);
+    let newest = r.seen_until ?? null;
+    for (const c of read) if (!newest || c.timestamp > newest) newest = c.timestamp;
+    const us = read.length ? await account.username() : "";
+    const fresh = ingest(r, read, rule, us, C);
+    if (!dryRun) r.resume = next ? { url: next, limit } : null;
+    if (next) d.log(`${iso()} ${name}: mais de ${maxPages * 50} comentários para ler; o resto vem na próxima passada`);
+    /* the list comes back empty, without error, when the token lacks instagram_business_manage_comments */
+    if (!read.length && !r.seen_until && m.comments_count > 0) {
+      r.warning = `o post tem ${m.comments_count} comentário(s) e a API não devolveu nenhum: o token tem instagram_business_manage_comments e o app está publicado (Live)?`;
+      d.log(`${iso()} ${name}: ${r.warning}`);
+    } else delete r.warning;
+    /* the count moves before the list does: if it changed but nothing newer than the cursor came
+       back, the list is lagging. Keep the old count so the next pass reads again, for up to
+       COUNT_LAG_MS (a deleted comment also lowers the count and would otherwise reread forever) */
+    const lagging = !dryRun && r.count != null && m.comments_count !== r.count && newest === r.seen_until;
+    if (lagging) r.count_lag_since ??= iso();
+    if (!lagging || now - Date.parse(r.count_lag_since ?? iso()) > COUNT_LAG_MS) {
+      r.count = m.comments_count;
+      delete r.count_lag_since;
+    }
+    if (newest) r.seen_until = newest;
+    if (dryRun)
+      d.log(`${name}: ${m.comments_count} comentário(s) no post, ${read.length} lido(s) agora, ${fresh} disparam`);
+  }
+
+  /* 2. the request in the middle of a sentence: the classifier decides from the post's context */
+  const uncertain = Object.entries(r.comments).filter(([, c]) => c.state === "uncertain");
+  if (uncertain.length && classify) {
+    applyClassification(uncertain, await classify(uncertain), C);
+    if (dryRun)
+      for (const [, c] of uncertain)
+        d.log(
+          `  em dúvida, @${c.username ?? "?"}: "${c.text.slice(0, 60)}" → ${c.state === "queued" ? "manda" : c.state === "skipped" ? "não manda" : "sem resposta do Claude"}`,
+        );
+    await persist();
+  }
+
+  /* 3. the queue: oldest comment to newest, up to the pass maximum */
+  const queue = pendingOf(r).sort(([, a], [, b]) => a.commented_at.localeCompare(b.commented_at));
+  let done = 0;
+  try {
+    for (const [cid, c] of queue) {
+      if (done >= C.max_per_pass) break;
+      if (now - Date.parse(c.commented_at) > DM_DEADLINE && !c.dm?.at) {
+        Object.assign(c, { state: "failed", error: "passou dos 7 dias que a Meta dá para responder pela DM" });
+        continue;
+      }
+      if (dryRun) {
+        d.log(`  @${c.username ?? "?"}: "${c.text.slice(0, 60)}"`);
+        if (gateOn(rule)) {
+          d.log(`    DM: ${openingText(rule, c.username, C)} [${buttonLabel(rule, C)}]`);
+          d.log(
+            `    ao tocar${rule.require_follow ? " (se seguir)" : ""}: ${deliveryPreview(rule, c.username, post, C).replace(/\n/g, " ⏎ ")}`,
+          );
+        } else d.log(`    DM: ${deliveryPreview(rule, c.username, post, C).replace(/\n/g, " ⏎ ")}`);
+        d.log(`    pública: ${publicReplyText(rule, c.username, C, d.random) ?? "nenhuma"}`);
+        done++;
+        continue;
+      }
+      if (done) await d.sleep((C.pause_between_s + d.random() * C.pause_between_s) * 1000);
+      await reply({ cid, c, rule, account, media, name, post, C, ...d });
+      done++;
+      await persist();
+    }
+  } finally {
+    await persist();
+  }
+  if (dryRun && !queue.length) d.log("  nada para responder");
+  return r;
+}

package/tools/lib/omnichat/record.mjs

@@ -0,0 +1,208 @@
+/* The record and the rule over time: totals, retrying what failed, who was left
+   without a DM, and what happens to the rule when the post goes up. Pure. */
+
+import { DM_DEADLINE } from "./config.mjs";
+import { triggers } from "./match.mjs";
+import { accountReplies, authorOf } from "./pass.mjs";
+import { deliveryPreview, gateOn, newRule, openingText, ruleProblems } from "./text.mjs";
+
+/** @typedef {import("./match.mjs").Rule} Rule */
+/** @typedef {import("./config.mjs").OmnichatConfig} OmnichatConfig */
+/** @typedef {import("./pass.mjs").CommentRecord} CommentRecord */
+
+/**
+ * The record's comments, newest first, with their id.
+ * @param {{ comments?: Record<string, CommentRecord> } | null | undefined} r
+ */
+export const recordItems = r =>
+  Object.entries(r?.comments ?? {})
+    .map(([id, c]) => ({ id, ...c }))
+    .sort((a, b) => b.commented_at.localeCompare(a.commented_at));
+
+/**
+ * @param {Array<CommentRecord>} items
+ */
+export function totals(items) {
+  const t = {
+    triggers: items.length,
+    dms: 0,
+    public_replies: 0,
+    queued: 0,
+    uncertain: 0,
+    failures: 0,
+    awaiting: 0,
+    delivered: 0,
+  };
+  for (const c of items) {
+    if (c.dm?.at) t.dms++;
+    if (c.public_reply?.at) t.public_replies++;
+    if (c.state === "queued" || c.state === "retry") t.queued++;
+    if (c.state === "failed") t.failures++;
+    if (c.gate?.state === "delivered") t.delivered++;
+    else if (c.gate) t.awaiting++;
+    if (c.state === "uncertain") t.uncertain++;
+  }
+  return t;
+}
+
+/**
+ * What failed without a delivered DM goes back to the queue; past Meta's 7 days there is no way back.
+ * Mutates the record.
+ * @param {{ comments?: Record<string, CommentRecord>, next_check?: string | null } | null | undefined} r
+ * @param {number} now
+ * @returns {{ n: number, old: number }}
+ */
+export function retryFailed(r, now) {
+  let n = 0,
+    old = 0;
+  for (const c of Object.values(r?.comments ?? {})) {
+    if (c.state !== "failed" || c.dm?.at) continue;
+    if (now - Date.parse(c.commented_at) > DM_DEADLINE) {
+      old++;
+      continue;
+    }
+    Object.assign(c, { state: "queued", attempts: 0, pauses: 0 });
+    delete c.error;
+    delete c.dm;
+    n++;
+  }
+  if (n && r) r.next_check = null;
+  return { n, old };
+}
+
+/**
+ * Who did not get the DM, from a fresh read of the post (read only).
+ * @param {{ read: any[], us: string, rec: Record<string, CommentRecord>, rule: Rule | null, now: number, C: OmnichatConfig }} p
+ */
+export function withoutDm({ read, us, rec, rule, now, C }) {
+  const replies = accountReplies(read, us);
+  return read
+    .filter(c => authorOf(c) !== us && !rec[c.id]?.dm?.at)
+    .map(c => {
+      const prev = rec[c.id];
+      return {
+        id: c.id,
+        username: c.from?.username ?? c.username ?? null,
+        text: c.text ?? "",
+        commented_at: c.timestamp,
+        /* what the agent already did with it (null: did not trigger, or not read yet) */
+        state: prev?.state ?? null,
+        reason: prev?.reason ?? prev?.error ?? null,
+        triggers: rule ? triggers(rule, c.text, C) : false,
+        account_reply: replies(c)[0]?.text ?? null,
+        /* Meta only accepts the DM up to 7 days after the comment */
+        within_deadline: now - Date.parse(c.timestamp) <= DM_DEADLINE,
+      };
+    });
+}
+
+/**
+ * The whole post as a chat: every top-level comment with the replies nested in it (people's and the
+ * account's), its status and the DM it got. The account's loose comments that @ someone nest under that
+ * person's latest comment before it (the way the app threads them). Read only.
+ * @param {{ read: any[], us: string, rec: Record<string, CommentRecord>, rule: Rule | null, now: number,
+ *   post: string | null, C: OmnichatConfig }} p
+ */
+export function thread({ read, us, rec, rule, now, post, C }) {
+  /** @param {any} x */
+  const node = x => ({
+    id: x.id,
+    username: x.from?.username ?? x.username ?? null,
+    text: x.text ?? "",
+    at: x.timestamp,
+    own: authorOf(x) === us,
+  });
+  /** the loose comments of the account that mention someone: nested under that person's comment */
+  const loose = new Map();
+  const tops = [];
+  const byAuthor = new Map();
+  for (const c of [...read].sort((a, b) => a.timestamp.localeCompare(b.timestamp)))
+    if (authorOf(c) !== us) byAuthor.set(authorOf(c), [...(byAuthor.get(authorOf(c)) ?? []), c]);
+  for (const c of read) {
+    if (authorOf(c) === us) {
+      const mention = String(c.text ?? "").match(/@([\w.]+)/);
+      const target = mention
+        ? (byAuthor.get(mention[1].toLowerCase().replace(/\.$/, "")) ?? [])
+            .filter(x => x.timestamp <= c.timestamp)
+            .at(-1)
+        : null;
+      if (target) {
+        loose.set(target.id, [...(loose.get(target.id) ?? []), { ...node(c), loose: true }]);
+        continue;
+      }
+    }
+    tops.push(c);
+  }
+  return tops.map(c => {
+    const prev = rec[c.id];
+    const own = authorOf(c) === us;
+    const dm = prev?.dm?.at
+      ? {
+          at: prev.dm.at,
+          /* older records did not keep the text: the rule's, as it reads today */
+          text:
+            prev.dm.text ??
+            (rule
+              ? gateOn(rule)
+                ? openingText(rule, prev.username, C)
+                : deliveryPreview(rule, prev.username, post, C)
+              : null),
+          exact: !!prev.dm.text,
+          gate: prev.gate?.state ?? null,
+        }
+      : null;
+    const replies = [...(c.replies?.data ?? []).map(node), ...(loose.get(c.id) ?? [])].sort((a, b) =>
+      a.at.localeCompare(b.at),
+    );
+    return {
+      ...node(c),
+      at: c.timestamp,
+      own,
+      replies,
+      dm,
+      /* what the agent already did with it (null: did not trigger, or not read yet) */
+      state: prev?.state ?? null,
+      reason: prev?.reason ?? prev?.error ?? null,
+      triggers: !own && rule ? triggers(rule, c.text, C) : false,
+      within_deadline: now - Date.parse(c.timestamp) <= DM_DEADLINE,
+    };
+  });
+}
+
+/**
+ * What happens to the rule when the post goes up. With enable_on_publish (the config's
+ * permanent approval) a rule not yet enabled enables now: without a rule it is born from
+ * the narration's keyword and the link found in the content; a draft enables as is. It
+ * never enables one the user disabled, one for any comment, nor one that doesn't add up
+ * (that one is written disabled, with the problems).
+ * @param {{ rule: Rule | null, enableOnPublish: boolean, keyword: () => string | null,
+ *   link: () => { link: string, found_in: string } | null, now: number, C: OmnichatConfig }} p
+ * @returns {{ kind: "already_enabled", rule: Rule } | { kind: "off" } | { kind: "disabled_by_user" } | { kind: "any_comment" }
+ *   | { kind: "no_keyword" }
+ *   | { kind: "draft", rule: Rule, problems: string[], born: { keyword: string, found: { link: string, found_in: string } | null } | null }
+ *   | { kind: "enable", rule: Rule, born: { keyword: string, found: { link: string, found_in: string } | null } | null }}
+ */
+export function publishedPlan({ rule, enableOnPublish, keyword, link, now, C }) {
+  if (rule?.enabled) return { kind: "already_enabled", rule };
+  if (!enableOnPublish) return { kind: "off" };
+  if (rule?.disabled_at) return { kind: "disabled_by_user" };
+  if (rule?.any_comment) return { kind: "any_comment" };
+  let r = rule;
+  let born = null;
+  if (!r) {
+    const kw = keyword();
+    if (!kw) return { kind: "no_keyword" };
+    const found = link();
+    r = {
+      ...newRule(C),
+      keywords: [kw],
+      generic_phrases: true,
+      link: found?.link ?? "",
+      updated_at: new Date(now).toISOString(),
+    };
+    born = { keyword: kw, found };
+  }
+  const problems = ruleProblems(r, C);
+  if (problems.length) return { kind: "draft", rule: r, problems, born };
+  return { kind: "enable", rule: { ...r, enabled: true, enabled_at: new Date(now).toISOString() }, born };
+}