brand-manager-worker 0.1.2 → 0.2.0

package/worker/ig-stats.js

@@ -0,0 +1,270 @@
+// Live Instagram stats, pulled from the Graph API instead of read off
+// screenshots. Rewrites stats/latest.md (and latest.json) so the drafting
+// agent always has a current media kit inlined.
+//
+// Trigger: refreshStatsIfStale() runs before every draft / outreach pitch.
+// It is cheap (four GETs) and never throws — a failed fetch leaves the last
+// snapshot in place and the staleness rule inside latest.md does the rest.
+//
+// Auth: an Instagram User access token (Instagram API with Instagram Login,
+// scope instagram_business_manage_insights) in ~/.goosetools/ig-token. The
+// dashboard's "Generate access tokens" button issues a 60-day long-lived
+// token; we refresh it ourselves once it is a week old, so it never expires
+// as long as the worker keeps running.
+
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { GOOSE_DIR, STATS_DIR } from "./paths.js";
+
+export const IG_TOKEN_FILE = join(GOOSE_DIR, "ig-token");
+const LATEST_MD = join(STATS_DIR, "latest.md");
+const LATEST_JSON = join(STATS_DIR, "latest.json");
+const GRAPH = "https://graph.instagram.com/v22.0";
+
+/** Refetch when the snapshot is older than this. A brand asking for numbers
+ *  gets at most a week-old window, and usually today's. */
+export const MAX_AGE_DAYS = 7;
+const TOKEN_REFRESH_DAYS = 7;
+const DAY = 86_400_000;
+
+function readToken() {
+  if (!existsSync(IG_TOKEN_FILE)) return null;
+  const t = readFileSync(IG_TOKEN_FILE, "utf8").trim();
+  return t || null;
+}
+
+async function get(token, path, params) {
+  const url = new URL(`${GRAPH}/${path}`);
+  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
+  url.searchParams.set("access_token", token);
+  const res = await fetch(url);
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || body.error) {
+    throw new Error(`IG ${path}: ${res.status} ${body.error?.message ?? ""}`.trim());
+  }
+  return body;
+}
+
+/** Long-lived tokens last 60 days; refreshing needs the token to be >24h old. */
+async function maybeRefreshToken(token) {
+  const ageDays = (Date.now() - statSync(IG_TOKEN_FILE).mtimeMs) / DAY;
+  if (ageDays < TOKEN_REFRESH_DAYS) return token;
+  try {
+    const r = await get(token, "refresh_access_token", { grant_type: "ig_refresh_token" });
+    if (r.access_token) {
+      writeFileSync(IG_TOKEN_FILE, r.access_token, { mode: 0o600 });
+      return r.access_token;
+    }
+  } catch (err) {
+    console.error(`· ig token refresh failed (using current token): ${err.message}`);
+  }
+  return token;
+}
+
+const breakdownOf = (insights) =>
+  insights.data?.[0]?.total_value?.breakdowns?.[0]?.results?.map((r) => ({
+    key: r.dimension_values[0],
+    value: r.value,
+  })) ?? [];
+
+/** Pull everything the media kit needs. Pure fetch; no file writes. */
+export async function fetchIgStats(token) {
+  const now = new Date();
+  const since = Math.floor((now.getTime() - 30 * DAY) / 1000);
+  const until = Math.floor(now.getTime() / 1000);
+
+  const profile = await get(token, "me", { fields: "username,followers_count,media_count" });
+
+  const totals = await get(token, "me/insights", {
+    metric: "reach,views,total_interactions,likes,comments,shares,saves,reposts",
+    period: "day",
+    metric_type: "total_value",
+    since: String(since),
+    until: String(until),
+  });
+  const t = Object.fromEntries(
+    (totals.data ?? []).map((m) => [m.name, m.total_value?.value ?? 0]),
+  );
+
+  const demo = {};
+  for (const b of ["gender", "age", "country", "city"]) {
+    const r = await get(token, "me/insights", {
+      metric: "follower_demographics",
+      period: "lifetime",
+      timeframe: "this_month",
+      breakdown: b,
+      metric_type: "total_value",
+    });
+    demo[b] = breakdownOf(r).sort((a, z) => z.value - a.value);
+  }
+
+  const media = await get(token, "me/media", {
+    fields: "id,media_product_type,timestamp",
+    limit: "50",
+  });
+  const cutoff = new Date(now.getTime() - 30 * DAY).toISOString();
+  const recent = (media.data ?? []).filter((m) => m.timestamp > cutoff);
+
+  return {
+    capturedAt: now.toISOString(),
+    windowStart: new Date(since * 1000).toISOString().slice(0, 10),
+    windowEnd: now.toISOString().slice(0, 10),
+    username: profile.username,
+    followers: profile.followers_count,
+    reach: t.reach ?? 0,
+    views: t.views ?? 0,
+    interactions: t.total_interactions ?? 0,
+    likes: t.likes ?? 0,
+    comments: t.comments ?? 0,
+    shares: t.shares ?? 0,
+    saves: t.saves ?? 0,
+    reposts: t.reposts ?? 0,
+    postsPosted: recent.length,
+    reelsPosted: recent.filter((m) => m.media_product_type === "REELS").length,
+    demographics: demo,
+  };
+}
+
+const k = (n) =>
+  n >= 1_000_000
+    ? `${(n / 1_000_000).toFixed(n >= 10_000_000 ? 0 : 1)}M`
+    : n >= 1_000
+      ? `${(n / 1_000).toFixed(n >= 10_000 ? 0 : 1)}K`
+      : String(n);
+const pct = (part, whole) => (whole ? `${((100 * part) / whole).toFixed(1)}%` : "n/a");
+const list = (rows, n, whole) =>
+  rows
+    .slice(0, n)
+    .map((r) => `${r.key} ${pct(r.value, whole)}`)
+    .join(", ");
+
+const AGE_ORDER = ["13-17", "18-24", "25-34", "35-44", "45-54", "55-64", "65+"];
+
+/** The media kit the agent reads. Keeps the same headings the screenshot
+ *  reader wrote, so anything that learned the old layout still works. */
+export function renderLatestMd(s, { screenshotsSection = "" } = {}) {
+  const captured = s.capturedAt.slice(0, 10);
+  const staleOn = new Date(Date.parse(s.capturedAt) + 30 * DAY).toISOString().slice(0, 10);
+  const g = s.demographics.gender ?? [];
+  const known = g.filter((r) => r.key === "M" || r.key === "F");
+  const knownTotal = known.reduce((a, r) => a + r.value, 0);
+  const men = known.find((r) => r.key === "M")?.value ?? 0;
+  const women = known.find((r) => r.key === "F")?.value ?? 0;
+  const ages = (s.demographics.age ?? []).slice();
+  const ageTotal = ages.reduce((a, r) => a + r.value, 0);
+  ages.sort((a, z) => AGE_ORDER.indexOf(a.key) - AGE_ORDER.indexOf(z.key));
+  const core = ages
+    .filter((r) => ["18-24", "25-34", "35-44"].includes(r.key))
+    .reduce((a, r) => a + r.value, 0);
+  const countryTotal = (s.demographics.country ?? []).reduce((a, r) => a + r.value, 0);
+  const cityTotal = (s.demographics.city ?? []).reduce((a, r) => a + r.value, 0);
+  const eng = pct(s.interactions, s.reach);
+
+  return `# @${s.username} — media kit
+
+_Source: Instagram Graph API (live). Window: ${s.windowStart} to ${s.windowEnd} (30 days). Captured ${captured}._
+
+## STALENESS RULE (read before using any number below)
+- This snapshot is **current only within 30 days of its capture date** (line above). Compare against
+  today's date. Captured ${captured} means it goes stale on ${staleOn}.
+- If stale: do **not** put any of these numbers or the screenshots in a draft, even when a brand asks.
+  Write the sentence as "I can send over current reach and audience numbers" and add the flag
+  \`"stats stale since ${staleOn} — refresh before sending"\` to the decision JSON so Erin refreshes.
+- If current: numbers go out only when asked (see \`playbook/negotiation.md\`, standing rule).
+
+## Headline (30 days)
+- **Followers:** ${s.followers.toLocaleString("en-US")} (~${k(s.followers)})
+- **Views:** ${k(s.views)}
+- **Accounts reached:** ${k(s.reach)}
+- **Posts:** ${s.postsPosted} (${s.reelsPosted} Reels)
+
+## Engagement (30 days)
+- Likes ${k(s.likes)} · Comments ${k(s.comments)} · Reposts ${k(s.reposts)} · Shares ${k(s.shares)} · Saves ${k(s.saves)}
+- ~${k(s.interactions)} total interactions → **~${eng} engagement by reach**
+
+## Audience (followers)
+- **Gender:** ${pct(men, knownTotal)} men / ${pct(women, knownTotal)} women (of followers who state one)
+- **Age:** ${ages.map((r) => `${r.key} = ${pct(r.value, ageTotal)}`).join(", ")} — ~${pct(core, ageTotal)} aged 18–44.
+- **Top countries:** ${list(s.demographics.country ?? [], 5, countryTotal)}
+- **Top cities:** ${list(s.demographics.city ?? [], 5, cityTotal)}
+- **Niche:** developers / engineers / tech workers (coding, dev life, WFH).
+
+## How to present reach (only when a brand asks for stats / media kit)
+Lead with views/reach, then note that content performs well above the follower count when it does.
+e.g. "Over the last 30 days my Reels pulled ~${k(s.views)} views and reached ~${k(s.reach)} accounts, with ~${eng}
+engagement by reach. Audience is mostly developers, engineers, and tech workers."
+Use these exact figures, never ones from older drafts or the voice file. Never use this framing
+unprompted, to justify a rate, or to correct a brand's benchmark.
+
+${screenshotsSection.trim() || `## Screenshots to attach on request
+Screenshots live in \`screenshots/\`; newest by date prefix is current. If none are newer than this
+snapshot's window, say the numbers come from Instagram's own insights and offer a screenshot on request.`}
+`;
+}
+
+/** Capture date of the current snapshot, or null if there is none. */
+export function snapshotCapturedAt() {
+  if (existsSync(LATEST_JSON)) {
+    try {
+      return JSON.parse(readFileSync(LATEST_JSON, "utf8")).capturedAt ?? null;
+    } catch {
+      /* fall through to the markdown */
+    }
+  }
+  if (!existsSync(LATEST_MD)) return null;
+  const m = readFileSync(LATEST_MD, "utf8").match(/Captured (\d{4}-\d{2}-\d{2})/);
+  return m ? m[1] : null;
+}
+
+/** Fetch now and rewrite latest.md/json. Returns the stats object. */
+export async function refreshStats() {
+  let token = readToken();
+  if (!token) throw new Error(`no Instagram token at ${IG_TOKEN_FILE}`);
+  token = await maybeRefreshToken(token);
+  const stats = await fetchIgStats(token);
+
+  // Keep the screenshot list only if it has a capture inside this window;
+  // June screenshots next to September numbers would contradict the kit.
+  const prior = existsSync(LATEST_MD) ? readFileSync(LATEST_MD, "utf8") : "";
+  const shotsSection = prior.match(/## Screenshots to attach on request[\s\S]*$/)?.[0] ?? "";
+  const shotDates = [...shotsSection.matchAll(/screenshots\/(\d{4}-\d{2}-\d{2})/g)].map((m) => m[1]);
+  const shots = shotDates.some((d) => d >= stats.windowStart) ? shotsSection : "";
+  writeFileSync(LATEST_MD, renderLatestMd(stats, { screenshotsSection: shots }));
+  writeFileSync(LATEST_JSON, JSON.stringify(stats, null, 2));
+  return stats;
+}
+
+/**
+ * The pre-draft hook. Refreshes when the snapshot is older than MAX_AGE_DAYS
+ * (or missing). Never throws: no token, network down, or a Meta error all
+ * leave the previous snapshot alone and log one line.
+ */
+export async function refreshStatsIfStale({ maxAgeDays = MAX_AGE_DAYS, log = console } = {}) {
+  if (!readToken()) return { refreshed: false, reason: "no-token" };
+  const at = snapshotCapturedAt();
+  const ageDays = at ? (Date.now() - Date.parse(at)) / DAY : Infinity;
+  if (ageDays < maxAgeDays) return { refreshed: false, reason: "fresh", ageDays };
+  try {
+    const s = await refreshStats();
+    log.log(
+      `· ig stats refreshed: ${k(s.followers)} followers, ${k(s.views)} views / ${k(s.reach)} reach (30d)`,
+    );
+    return { refreshed: true, stats: s };
+  } catch (err) {
+    log.error(`· ig stats refresh failed (keeping last snapshot): ${err.message}`);
+    return { refreshed: false, reason: "error", error: err.message };
+  }
+}
+
+// `node worker/ig-stats.js` — refresh on demand from a terminal.
+if (process.argv[1] && process.argv[1].endsWith("ig-stats.js")) {
+  refreshStats()
+    .then((s) => {
+      console.log(readFileSync(LATEST_MD, "utf8"));
+      console.log(`wrote ${LATEST_MD} (captured ${s.capturedAt})`);
+    })
+    .catch((err) => {
+      console.error(err.message);
+      process.exit(1);
+    });
+}

package/worker/index.js

@@ -17,12 +17,21 @@ import { setAgent } from "./claude.js";
 import {
   runChat,
   runDraft,
+  runCompact,
   runEdit,
   runLearn,
   runScan,
   runStats,
   runVoiceAudit,
 } from "./handlers.js";
+import { acquireWorkerLock } from "./lock.js";
+
+// One worker of each kind per machine — a second one would split the queue
+// with this one. Stands down with an explanation if another already holds it.
+acquireWorkerLock("brand", {
+  label: "The Brand Manager worker",
+  stopHint: "launchctl bootout gui/$(id -u)/com.goosetools.brand   (or close its terminal)",
+});
 
 if (!TOKEN) {
   console.error(
@@ -67,6 +76,8 @@ async function handle(job) {
       return runStats(job);
     case "edit":
       return runEdit(job);
+    case "compact":
+      return runCompact(job);
     // Brand Outreach (its own tool on the site; same worker, same token).
     case "outreach-chat":
       return runOutreachChat(job);

package/worker/lock.js

@@ -0,0 +1,103 @@
+// One worker of each kind per machine.
+//
+// Nothing stops you starting a second worker: the daemon runs in the
+// background, and `run` in a terminal is the normal way to watch one work or
+// to try a change from a checkout. Both then poll the same queue with the same
+// token.
+//
+// The server is safe — claiming a job is a single compare-and-set, so two
+// workers never get the same one. The damage is quieter than that. They SPLIT
+// the queue, so jobs land on whichever copy happened to pick them up: half
+// from the code you're editing, half from the installed release, with a
+// different state directory behind each. And the polling doubles, which is
+// what the idle interval exists to keep down in the first place.
+//
+// So: whoever gets here first holds the lock, and the second one stands down
+// with an explanation instead of quietly competing.
+
+import { execFileSync } from "node:child_process";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const LOCK_DIR = join(homedir(), ".goosetools", "locks");
+
+/**
+ * Take the lock for `name` ("worker", "caption", "brand", "overlay"), or print
+ * who has it and exit. Returns nothing — it either succeeds or ends the
+ * process.
+ *
+ * `stopHint` is the command that stops the OTHER copy, and it's the whole
+ * point of the message: "already running" without it just moves the puzzle.
+ */
+export function acquireWorkerLock(name, { label, stopHint }) {
+  mkdirSync(LOCK_DIR, { recursive: true });
+  const file = join(LOCK_DIR, `${name}.pid`);
+
+  const holder = readHolder(file);
+  if (holder && isAlive(holder.pid)) {
+    console.log(
+      `\n${label} is already running on this computer (pid ${holder.pid}${
+        holder.since ? `, since ${holder.since}` : ""
+      }).\n\n` +
+        "Two of them would split the queue between them — some jobs done by\n" +
+        "one copy, some by the other. Stopping here instead.\n\n" +
+        `  Stop the other one:  ${stopHint}\n`,
+    );
+    process.exit(0);
+  }
+
+  // Either no lock, or one left behind by a worker that was killed. Both are
+  // ours to take: an O_EXCL create loses to a worker that beat us here by
+  // milliseconds, which is the one race worth caring about.
+  if (holder) rmSync(file, { force: true });
+  let fd;
+  try {
+    fd = openSync(file, "wx");
+  } catch {
+    console.log(`\n${label} started somewhere else a moment ago. Stopping here.\n`);
+    process.exit(0);
+  }
+  writeSync(fd, `${process.pid}\n${new Date().toISOString()}\n`);
+  closeSync(fd);
+
+  const release = () => rmSync(file, { force: true });
+  process.on("exit", release);
+  for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(sig, () => {
+      release();
+      process.exit(0);
+    });
+  }
+}
+
+function readHolder(file) {
+  if (!existsSync(file)) return null;
+  try {
+    const [pid, since] = readFileSync(file, "utf8").split("\n");
+    const n = Number.parseInt(pid, 10);
+    return Number.isFinite(n) ? { pid: n, since: since?.trim() || null } : null;
+  } catch {
+    return null;
+  }
+}
+
+// A pid file outlives a SIGKILLed worker, and pids get reused — so "is that
+// pid alive" isn't enough on its own. Checking that it's a node process is
+// cheap and rules out the reuse case that would otherwise lock out the daemon
+// until someone deleted the file by hand.
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+  try {
+    return /node/.test(execFileSync("ps", ["-p", String(pid), "-o", "command="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }));
+  } catch {
+    return false;
+  }
+}

package/worker/outreach.js

@@ -13,6 +13,7 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { BASE_DIR, BRAND_DIR, PLAYBOOK_DIR, STATS_DIR, VOICE_DIR } from "./paths.js";
+import { refreshStatsIfStale } from "./ig-stats.js";
 import { oneShot, parseJson, session, canResume } from "./claude.js";
 import { createGmailDraft } from "./gmail-draft.js";
 
@@ -104,6 +105,7 @@ export async function runOutreachDraft(job) {
   if (!job.gmailAccessToken)
     return { ok: false, error: "Connect Gmail on goosetools.com first" };
 
+  await refreshStatsIfStale();
   const prompt = `${outreachMode()}
 
 ## The creator's layers (personal wins over base on any conflict)

package/worker/record-write.js

@@ -0,0 +1,154 @@
+// Writing observations back into a brand record.
+//
+// The drafting pass used to be read-only: decide() runs tools-off, so a scan
+// that produced ten replies updated zero files. When Heli pulled the Navan
+// go-live at 08:25 on the morning it was due, the agent drafted a reply about
+// it and the calendar block kept the dead date forever.
+//
+// Rather than pay for a second, tool-enabled agent pass per thread, the draft
+// decision carries a `recordUpdates` object and this merges it in with plain
+// code. Same run, no extra call, no added latency — and because the merge is
+// deterministic it can't wander off and rewrite prose it wasn't asked to.
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { DEALS_DIR } from "./paths.js";
+import { appendDecisions, mergeRecord, parseRecord, serializeRecord } from "./record.js";
+
+const SLUG_RE = /^[a-z0-9-]+$/;
+
+/** Guess a ledger filename from a brand name: "Navan Edge" -> "navan-edge". */
+export function slugify(brand) {
+  return String(brand ?? "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+/**
+ * Find the ledger a brand name belongs to without creating one by accident.
+ * An exact slug hit wins; otherwise a prefix match, so a draft that says
+ * "Navan" still lands on navan.md. Returns null when nothing matches — the
+ * caller must not invent a file, because a typo'd brand name would otherwise
+ * quietly fork a deal into two records.
+ */
+export function resolveSlug(brand, known) {
+  const slug = slugify(brand);
+  if (!slug) return null;
+  if (known.includes(slug)) return slug;
+  return known.find((k) => k.startsWith(slug) || slug.startsWith(k)) ?? null;
+}
+
+/**
+ * Apply `recordUpdates` to deals/<slug>.md.
+ *
+ * Returns a short description of what changed, or null if nothing did — the
+ * caller logs it against the draft so a surprising edit is traceable to the
+ * email that caused it.
+ */
+export function applyRecordUpdates(slug, updates) {
+  if (!SLUG_RE.test(slug ?? "")) return null;
+  if (!updates || typeof updates !== "object") return null;
+
+  const path = join(DEALS_DIR, `${slug}.md`);
+  if (!existsSync(path)) return null;
+
+  const md = readFileSync(path, "utf8");
+  const { record, decisions } = parseRecord(md);
+  if (!record) return null;
+
+  const { decisions: incoming, ...rest } = updates;
+  const nextRecord = mergeRecord(record, rest);
+  const nextDecisions = appendDecisions(decisions, Array.isArray(incoming) ? incoming : []);
+
+  const changed = summarize(record, nextRecord, decisions.length, nextDecisions.length);
+  if (!changed) return null;
+
+  writeFileSync(
+    path,
+    serializeRecord({
+      record: nextRecord,
+      decisions: nextDecisions,
+      archiveRef: existsSync(join(DEALS_DIR, "..", "archive", `${slug}.md`))
+        ? `archive/${slug}.md`
+        : null,
+    }),
+  );
+  return changed;
+}
+
+/**
+ * Record her answer to "were you actually paid?".
+ *
+ * This is the only fact in the system that starts on the website, so it has to
+ * end up in the file or the mirror becomes storage. mergeRecord() then treats
+ * `confirmed` as untouchable, so the agent re-reading the same ambiguous email
+ * can't flip it back.
+ */
+export function applyPaymentConfirmation(slug, { invoiceId, paid }) {
+  if (!SLUG_RE.test(slug ?? "")) return null;
+
+  const path = join(DEALS_DIR, `${slug}.md`);
+  if (!existsSync(path)) return null;
+
+  const md = readFileSync(path, "utf8");
+  const { record, decisions } = parseRecord(md);
+  if (!record) return null;
+
+  const invoices = record.money?.invoices ?? [];
+  const i = invoices.findIndex((inv) => inv.id === invoiceId);
+  if (i === -1) return null;
+
+  const next = {
+    ...record,
+    money: {
+      ...record.money,
+      invoices: invoices.map((inv, n) =>
+        n === i
+          ? {
+              ...inv,
+              confirmed: paid,
+              // The stamp is what makes the confirmation real — sanitizeInvoice
+              // discards a `confirmed` that arrives without it.
+              confirmedAt: new Date().toISOString(),
+              status: paid ? "paid" : "unpaid",
+              // Her word is the ceiling on certainty, not the agent's guess.
+              confidence: 1,
+              evidence: `Confirmed by hand on ${new Date().toISOString().slice(0, 10)}: ${
+                paid ? "paid" : "not paid"
+              }. Previously: ${inv.evidence ?? "no evidence recorded"}`,
+            }
+          : inv,
+      ),
+    },
+  };
+
+  writeFileSync(path, serializeRecord({ record: next, decisions, archiveRef: archiveRefFor(slug) }));
+  return `${slug} ${invoiceId}: ${paid ? "confirmed paid" : "confirmed NOT paid"}`;
+}
+
+function archiveRefFor(slug) {
+  return existsSync(join(DEALS_DIR, "..", "archive", `${slug}.md`)) ? `archive/${slug}.md` : null;
+}
+
+function summarize(before, after, beforeDecisions, afterDecisions) {
+  const bits = [];
+  if (before.stage !== after.stage) bits.push(`stage ${before.stage ?? "?"} -> ${after.stage}`);
+  if (before.whoseMove !== after.whoseMove) bits.push(`move -> ${after.whoseMove}`);
+
+  const dateChanges = (after.calendar ?? []).filter((e) => {
+    const old = (before.calendar ?? []).find((o) => o.key === e.key);
+    return !old || old.date !== e.date || old.tbd !== e.tbd;
+  }).length;
+  if (dateChanges) bits.push(`${dateChanges} date(s)`);
+
+  const invChanges = (after.money?.invoices ?? []).filter((inv) => {
+    const old = (before.money?.invoices ?? []).find((o) => o.id === inv.id);
+    return !old || old.status !== inv.status;
+  }).length;
+  if (invChanges) bits.push(`${invChanges} invoice(s)`);
+
+  if (afterDecisions > beforeDecisions) bits.push(`+${afterDecisions - beforeDecisions} decision(s)`);
+
+  return bits.length ? bits.join(", ") : null;
+}