brand-manager-worker 0.1.2 → 0.2.0

package/worker/record.js

@@ -0,0 +1,264 @@
+// The brand record — what replaced the ledger journal.
+//
+// A ledger used to be a chronological log the agent appended to forever.
+// navan.md reached 56KB across 44 dated headings, including entries explicitly
+// marked as superseded ("CORRECTED below, this read was wrong"), all of it
+// spent out of a shared 350k prompt budget. Of that, perhaps 3KB could ever
+// inform a future draft.
+//
+// A record is the opposite: current state, and the decisions that constrain
+// the next one. Two parts, both small.
+//
+//   <!-- brand {...} -->   machine-readable current state, rewritten in place
+//   ## Decisions           append-only one-liners — the durable precedent
+//
+// The narrative moves to archive/<slug>.md, which is NOT loaded into drafting
+// context. Chat can still read it when she asks for history.
+//
+// Why a JSON block inside markdown rather than a real database: these files are
+// hers. "Open Claude Code in this folder and talk to it" has to keep working,
+// and the website is a projection of the files, never the owner of them.
+
+/** Stages the board understands. Kept in sync with goosetools' BRAND_STAGES. */
+export const STAGES = [
+  "inbound",
+  "negotiating",
+  "contract",
+  "producing",
+  "posted",
+  "awaiting_pay",
+  "paid",
+  "declined",
+  "cancelled",
+];
+
+// The live ledgers drifted: the agent wrote whatever stage word fit the moment.
+const STAGE_ALIASES = {
+  scoping: "negotiating",
+  "in production": "producing",
+  "in-production": "producing",
+  signed: "contract",
+  dead: "declined",
+  rejected: "declined",
+  gifting: "inbound",
+  live: "posted",
+};
+
+export function normalizeStage(raw) {
+  if (!raw) return null;
+  const s = String(raw).trim().toLowerCase().replace(/\s+/g, " ");
+  if (STAGES.includes(s)) return s;
+  return STAGE_ALIASES[s] ?? s;
+}
+
+/**
+ * `confirmed` is the creator's answer and nobody else's: true, false, or null
+ * for "never asked". The agent has no business writing it — but it did, twice
+ * in one migration (a bare `false` on Navan, a date string on Microsoft), and
+ * either one silences the "were you actually paid?" prompt for that invoice
+ * and then freezes the value against every later update.
+ *
+ * A type check can't catch it: the agent's `false` and her "no" are the same
+ * boolean. So a confirmation only counts when it carries `confirmedAt`, which
+ * applyPaymentConfirmation() stamps and nothing else writes. Provenance, not
+ * shape — which also means a record hand-edited in a terminal needs the stamp
+ * too, and that is the right trade for a field this load-bearing.
+ */
+export function sanitizeInvoice(inv) {
+  if (!inv || typeof inv !== "object") return inv;
+  const vouched = typeof inv.confirmed === "boolean" && typeof inv.confirmedAt === "string";
+  return vouched ? inv : { ...inv, confirmed: null, confirmedAt: null };
+}
+
+const blockRe = (name) => new RegExp(`<!--\\s*${name}\\s([\\s\\S]*?)-->`, "i");
+
+/**
+ * Read one `<!-- name {...} -->` block. Returns null rather than throwing:
+ * these blocks are model-written, and a malformed one must degrade to "we
+ * don't know" instead of taking down a scan.
+ */
+export function readBlock(md, name) {
+  const m = String(md ?? "").match(blockRe(name));
+  if (!m) return null;
+  try {
+    return JSON.parse(m[1]);
+  } catch {
+    return null;
+  }
+}
+
+/** Replace a block in place, or append one if the file has none. */
+export function writeBlock(md, name, value) {
+  const body = `<!-- ${name}\n${JSON.stringify(value, null, 2)}\n-->`;
+  const src = String(md ?? "");
+  return blockRe(name).test(src) ? src.replace(blockRe(name), body) : `${src.trimEnd()}\n\n${body}\n`;
+}
+
+const DECISION_RE = /^[-*]\s+(\d{4}-\d{2}-\d{2})\s*·\s*(.+)$/;
+
+/** One line per decision: `- 2026-07-15 · accepted $14,000 · 2yr paid usage` */
+export function parseDecisions(md) {
+  const section = String(md ?? "").split(/^##\s+Decisions\s*$/im)[1];
+  if (!section) return [];
+
+  const out = [];
+  for (const line of section.split("\n")) {
+    if (/^##\s/.test(line)) break; // next heading ends the section
+    const m = line.trim().match(DECISION_RE);
+    if (m) {
+      const [what, ...why] = m[2].split("·").map((s) => s.trim());
+      out.push({ date: m[1], what, why: why.join(" · ") || null });
+    }
+  }
+  return out;
+}
+
+export function renderDecisions(decisions) {
+  return decisions
+    .slice()
+    .sort((a, b) => a.date.localeCompare(b.date))
+    .map((d) => `- ${d.date} · ${[d.what, d.why].filter(Boolean).join(" · ")}`)
+    .join("\n");
+}
+
+/**
+ * Read a record from either format. Files migrate one at a time and a scan can
+ * hit an un-migrated one at any point, so the legacy `board` + `calendar` pair
+ * has to keep working until every file has moved over.
+ */
+export function parseRecord(md) {
+  const src = String(md ?? "");
+  const brand = readBlock(src, "brand");
+
+  if (brand) {
+    return {
+      record: { ...brand, stage: normalizeStage(brand.stage), money: sanitizeMoney(brand.money) },
+      decisions: parseDecisions(src),
+      legacy: false,
+    };
+  }
+
+  const board = readBlock(src, "board");
+  const calendar = readBlock(src, "calendar");
+  if (!board && !calendar) return { record: null, decisions: parseDecisions(src), legacy: true };
+
+  return { record: fromLegacyBoard(board ?? {}, calendar), decisions: [], legacy: true };
+}
+
+function sanitizeMoney(money) {
+  if (!money || typeof money !== "object") return money ?? null;
+  return { ...money, invoices: (money.invoices ?? []).map(sanitizeInvoice) };
+}
+
+/** Lift the old board block into a record. Terms stay strings — see below. */
+export function fromLegacyBoard(board, calendar) {
+  const agencyRaw = typeof board.agency === "string" ? board.agency.trim() : "";
+  // Live data writes "Freeman & Forrest · Rebekah Greene" in one string.
+  const [agencyName, agencyContact] = agencyRaw.split("·").map((s) => s.trim());
+
+  return {
+    brand: board.brand ?? null,
+    agency: agencyName ? { name: agencyName, contact: agencyContact || null } : null,
+    contacts: board.contact ? [board.contact] : [],
+    stage: normalizeStage(board.stage),
+    whoseMove: board.whoseMove ?? null,
+    deal: {
+      // Deliberately not parsed into a number here. The live values include
+      // "asked $2,000, countered $1,200" and "$3.7-4.4K (quoted)" — turning
+      // those into one integer would invent a fact. The migration pass reads
+      // them with judgement; this path only reshapes what is already there.
+      rate: board.rate ?? null,
+      deliverables: board.deliverables ?? null,
+      usage: board.usage ?? null,
+      postWindow: board.postWindow ?? null,
+    },
+    exclusivity: board.exclusivity ? { raw: board.exclusivity } : null,
+    money: null,
+    calendar: Array.isArray(calendar) ? calendar : [],
+    flags: Array.isArray(board.flags) ? board.flags : [],
+  };
+}
+
+export function serializeRecord({ record, decisions = [], archiveRef = null }) {
+  const parts = [`# ${record.brand ?? "Untitled"}`, "", writeBlock("", "brand", record).trim()];
+
+  if (decisions.length) parts.push("", "## Decisions", "", renderDecisions(decisions));
+  if (archiveRef) parts.push("", `_History: ${archiveRef}_`);
+
+  return `${parts.join("\n")}\n`;
+}
+
+/**
+ * Merge what the drafting agent observed into the stored record.
+ *
+ * Upserts by stable key so a re-observed date updates in place instead of
+ * accumulating duplicates. Two things are never overwritten: a payment Erin
+ * confirmed by hand, and a decision already on the log.
+ */
+export function mergeRecord(record, updates) {
+  if (!updates) return record;
+  const next = { ...record };
+
+  for (const k of ["stage", "whoseMove", "status"]) {
+    if (updates[k] != null) next[k] = k === "stage" ? normalizeStage(updates[k]) : updates[k];
+  }
+  if (updates.deal) next.deal = { ...(next.deal ?? {}), ...updates.deal };
+  if (updates.exclusivity) next.exclusivity = { ...(next.exclusivity ?? {}), ...updates.exclusivity };
+  if (Array.isArray(updates.flags)) next.flags = updates.flags;
+
+  if (Array.isArray(updates.calendar)) {
+    next.calendar = upsertBy(next.calendar ?? [], updates.calendar, "key");
+  }
+
+  if (updates.money) {
+    const prev = next.money ?? { invoices: [] };
+    next.money = {
+      ...prev,
+      ...updates.money,
+      invoices: upsertBy(prev.invoices ?? [], (updates.money.invoices ?? []).map(dropConfirmed), "id", (old, incoming) =>
+        // She answered "was I actually paid?" by hand. The agent re-reading the
+        // same ambiguous email must not quietly flip it back. This is the Navan
+        // Edge case: she believed she'd been paid and hadn't.
+        old.confirmed != null ? { ...incoming, ...pick(old, ["confirmed", "status", "paidAt"]) } : { ...old, ...incoming },
+      ),
+    };
+  }
+
+  return next;
+}
+
+/** An incoming update may never carry `confirmed` — only the creator sets it. */
+function dropConfirmed(inv) {
+  if (!inv || typeof inv !== "object") return inv;
+  const { confirmed, ...rest } = inv;
+  return rest;
+}
+
+function upsertBy(existing, incoming, key, resolve) {
+  const out = existing.slice();
+  for (const item of incoming) {
+    if (item?.[key] == null) continue;
+    const i = out.findIndex((e) => e?.[key] === item[key]);
+    if (i === -1) out.push(item);
+    else out[i] = resolve ? resolve(out[i], item) : { ...out[i], ...item };
+  }
+  return out;
+}
+
+function pick(obj, keys) {
+  return Object.fromEntries(keys.filter((k) => obj[k] !== undefined).map((k) => [k, obj[k]]));
+}
+
+/** Append decisions, skipping any we already recorded on the same date. */
+export function appendDecisions(existing, incoming = []) {
+  const seen = new Set(existing.map((d) => `${d.date}|${d.what?.toLowerCase()}`));
+  const out = existing.slice();
+  for (const d of incoming) {
+    if (!d?.date || !d?.what) continue;
+    const k = `${d.date}|${String(d.what).toLowerCase()}`;
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(d);
+  }
+  return out;
+}