@fayz-ai/plugin-financial 0.25.9 → 0.25.10

package/dist/chunk-7VKJLBYY.js

@@ -0,0 +1,1736 @@
+import * as React from 'react';
+import { revealPage, askAI, requestChatUpload, toInlineFile, useChatStore, createArchetypeLookup, adminNavigateTo, useAgentSurface, resolveEntityRoute } from '@fayz-ai/admin';
+import { round2 } from '@fayz-ai/financial/domain/money';
+import { formatCurrency } from '@fayz-ai/core';
+
+// src/views/payable-agent.tsx
+
+// src/lib/amount-in-words.ts
+var UNITS = {
+  zero: 0,
+  um: 1,
+  uma: 1,
+  dois: 2,
+  duas: 2,
+  tres: 3,
+  quatro: 4,
+  cinco: 5,
+  seis: 6,
+  sete: 7,
+  oito: 8,
+  nove: 9,
+  dez: 10,
+  onze: 11,
+  doze: 12,
+  treze: 13,
+  catorze: 14,
+  quatorze: 14,
+  quinze: 15,
+  dezesseis: 16,
+  dezasseis: 16,
+  dezessete: 17,
+  dezassete: 17,
+  dezoito: 18,
+  dezenove: 19,
+  dezanove: 19,
+  vinte: 20,
+  trinta: 30,
+  quarenta: 40,
+  cinquenta: 50,
+  cincoenta: 50,
+  sessenta: 60,
+  setenta: 70,
+  oitenta: 80,
+  noventa: 90,
+  cem: 100,
+  cento: 100,
+  duzentos: 200,
+  duzentas: 200,
+  trezentos: 300,
+  trezentas: 300,
+  quatrocentos: 400,
+  quatrocentas: 400,
+  quinhentos: 500,
+  quinhentas: 500,
+  seiscentos: 600,
+  seiscentas: 600,
+  setecentos: 700,
+  setecentas: 700,
+  oitocentos: 800,
+  oitocentas: 800,
+  novecentos: 900,
+  novecentas: 900
+};
+var SCALES = {
+  mil: 1e3,
+  milhao: 1e6,
+  milhoes: 1e6,
+  bilhao: 1e9,
+  bilhoes: 1e9
+};
+function normalize(text2) {
+  return text2.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/[^a-z\s]/g, " ").split(/\s+/).filter(Boolean);
+}
+function sumGroup(words) {
+  let total = 0;
+  for (const word of words) {
+    const value = UNITS[word];
+    if (value !== void 0) total += value;
+  }
+  return total;
+}
+function parseAmountInWords(raw) {
+  if (typeof raw !== "string") return null;
+  const words = normalize(raw);
+  if (!words.length) return null;
+  const centsAt = words.findIndex((w) => w === "centavo" || w === "centavos");
+  const whole = centsAt >= 0 ? words.slice(0, centsAt) : words;
+  const cents = centsAt >= 0 ? sumGroup(words.slice(0, centsAt).slice(lastCurrencyIndex(words, centsAt))) : 0;
+  let total = 0;
+  let group = [];
+  let sawNumber = false;
+  for (const word of whole) {
+    if (word === "centavo" || word === "centavos") break;
+    const scale = SCALES[word];
+    if (scale !== void 0) {
+      total += (sumGroup(group) || 1) * scale;
+      group = [];
+      sawNumber = true;
+      continue;
+    }
+    if (UNITS[word] !== void 0) {
+      group.push(word);
+      sawNumber = true;
+    }
+  }
+  total += sumGroup(group);
+  if (!sawNumber) return null;
+  const value = centsAt >= 0 && cents > 0 && cents < 100 ? total - cents + cents / 100 : total;
+  return value > 0 ? Math.round(value * 100) / 100 : null;
+}
+function lastCurrencyIndex(words, before) {
+  for (let i = before - 1; i >= 0; i--) {
+    if (words[i] === "real" || words[i] === "reais") return i + 1;
+  }
+  return before;
+}
+
+// src/views/payable-lines.ts
+function parseLineItems(raw) {
+  if (raw === void 0 || raw === null) return { items: [] };
+  if (!Array.isArray(raw)) return { items: [], error: "`items` must be an array of table rows." };
+  const items = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") continue;
+    const row = entry;
+    const description = typeof row.description === "string" ? row.description.trim() : "";
+    const unitPrice = parseReceiptAmount(row.unitPrice);
+    if (!description || unitPrice === null) {
+      return {
+        items: [],
+        error: 'Every row needs a `description` and a readable `unitPrice` copied from the paper ("47,90"). Re-read the table and resend all rows.'
+      };
+    }
+    const quantityRaw = typeof row.quantity === "number" ? row.quantity : Number(row.quantity);
+    const quantity = Number.isFinite(quantityRaw) && quantityRaw > 0 ? quantityRaw : 1;
+    items.push({ description, quantity, unitPrice });
+  }
+  return { items };
+}
+function text(value) {
+  const s = typeof value === "string" ? value.trim() : "";
+  return s || void 0;
+}
+function today() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+}
+
+// src/views/document-memory.ts
+var lastDocument = null;
+var DOCUMENT_TTL_MS = 15 * 60 * 1e3;
+var STORAGE_KEY = "fayz:financial:last-document-read";
+function readStored() {
+  try {
+    const raw = globalThis.sessionStorage?.getItem(STORAGE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed.at === "number" && parsed.doc ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function writeStored(entry) {
+  try {
+    if (entry) globalThis.sessionStorage?.setItem(STORAGE_KEY, JSON.stringify(entry));
+    else globalThis.sessionStorage?.removeItem(STORAGE_KEY);
+  } catch {
+  }
+}
+function rememberedDocument() {
+  const entry = lastDocument ?? readStored();
+  if (!entry) return null;
+  if (Date.now() - entry.at > DOCUMENT_TTL_MS) {
+    clearRememberedDocument();
+    return null;
+  }
+  lastDocument = entry;
+  return entry.doc;
+}
+function clearRememberedDocument() {
+  lastDocument = null;
+  writeStored(null);
+}
+function normalizeDocument(args) {
+  const parsed = parseLineItems(args.items);
+  const items = parsed.error ? [] : parsed.items;
+  const shipping = parseReceiptAmount(args.shipping) ?? void 0;
+  const subtotal = parseReceiptAmount(args.subtotal) ?? void 0;
+  const total = parseReceiptAmount(args.total) ?? void 0;
+  const lineSum = items.length ? round2(items.reduce((s, i) => s + i.quantity * i.unitPrice, 0)) : void 0;
+  const computed = lineSum === void 0 ? void 0 : round2(lineSum + (shipping ?? 0));
+  const reconciles = computed === void 0 || total === void 0 ? false : Math.abs(computed - total) <= 0.02;
+  return {
+    items,
+    ...subtotal === void 0 ? {} : { subtotal },
+    ...shipping === void 0 ? {} : { shipping },
+    ...total === void 0 ? {} : { total },
+    ...lineSum === void 0 ? {} : { lineSum },
+    reconciles,
+    ...parseReceiptDate(args.documentDate) ? { documentDate: parseReceiptDate(args.documentDate) } : {},
+    // `null` é uma RESPOSTA: "o papel não diz". Diferente de "ainda não li".
+    dueDate: parseReceiptDate(args.dueDate) ?? null,
+    ...parseReceiptDate(args.paymentDate) ? { paymentDate: parseReceiptDate(args.paymentDate) } : {},
+    ...text(args.orderRef) ? { orderRef: text(args.orderRef) } : {},
+    ...parseReceiptDate(args.deliveryDate) ? { deliveryDate: parseReceiptDate(args.deliveryDate) } : {},
+    ...text(args.paymentMethod) ? { method: text(args.paymentMethod) } : {}
+  };
+}
+function rememberDocument(doc, meta) {
+  lastDocument = {
+    at: Date.now(),
+    doc,
+    ...meta?.source ? { source: meta.source } : {},
+    ...meta?.conversationId ? { conversationId: meta.conversationId } : {}
+  };
+  writeStored(lastDocument);
+}
+var RECEIPT_INTRO = {
+  role: "finance",
+  persona: "Leitor de recibos",
+  pitch: "Fotografe o recibo que eu leio e preencho a conta.",
+  description: "Leio o que est\xE1 no papel \u2014 fornecedor, valor e data \u2014, digo o que entendi e abro o cadastro j\xE1 preenchido para voc\xEA conferir. N\xE3o gravo nada sozinho: quem confirma \xE9 voc\xEA.",
+  suggestions: [
+    { label: "O que voc\xEA consegue ler de um recibo?" },
+    { label: "E se a foto estiver torta ou escura?" }
+  ]
+};
+var RECEIPT_INSTRUCTIONS = [
+  "A pessoa vai mandar a FOTO de um recibo ou nota. Leia a imagem e extraia apenas o que est\xE1 escrito nela.",
+  "Termine o turno CHAMANDO `openPayableDraft` com o que leu. Descrever o recibo em texto n\xE3o abre nada:",
+  "sem a chamada a pessoa fica olhando para uma frase e para nenhum formul\xE1rio. N\xE3o anuncie que vai abrir \u2014",
+  "abra.",
+  'O valor vai COPIADO como est\xE1 escrito \u2014 "50,00", n\xE3o 5000. A v\xEDrgula \xE9 decimal em portugu\xEAs, e',
+  "convert\xEA-la voc\xEA mesmo j\xE1 transformou cinquenta reais em cinco mil.",
+  'Se o papel escreve o valor POR EXTENSO ("CINQUENTA REAIS"), copie em `amountInWords`. Num recibo',
+  'manuscrito \xE9 ele que manda: os algarismos v\xEAm com um tra\xE7o entre reais e centavos ("50|00") que n\xE3o',
+  "\xE9 v\xEDrgula, e \xE9 exatamente por isso que o recibo escreve o valor duas vezes.",
+  "Preencha os campos NESTA ORDEM antes de chamar: valor, data, descri\xE7\xE3o, fornecedor \u2014 e s\xF3 ent\xE3o",
+  "`notes`, com o que sobrou. `notes` \xE9 o resto, nunca o lugar de algo que tem campo pr\xF3prio: a data",
+  'escrita como "Rio, 20/01/22" \xE9 a DATA, e "proveniente da presta\xE7\xE3o de servi\xE7o de t\xE1xi" \xE9 a',
+  "DESCRI\xC7\xC3O. Enfiadas nas observa\xE7\xF5es, elas somem dos campos onde a pessoa vai procur\xE1-las.",
+  'N\xC3O confunda as linhas do recibo: "a import\xE2ncia de CINQUENTA REAIS" \xE9 o VALOR por extenso, n\xE3o',
+  "um fornecedor chamado Cinquenta Reais. Sem um nome claro de quem recebeu, deixe `supplier` de fora.",
+  "Ponha em `notes` tudo o mais que est\xE1 escrito e n\xE3o coube nos outros campos: itiner\xE1rio, placa,",
+  "n\xFAmero do documento, quem assinou. \xC9 onde a pessoa vai procurar o que o papel dizia.",
+  "N\xC3O invente campo que o papel n\xE3o responde. Vencimento, categoria e conta de pagamento quase nunca est\xE3o",
+  "num recibo: deixe de fora. Campo vazio custa um toque; campo errado custa uma confer\xEAncia inteira.",
+  "S\xF3 existe uma raz\xE3o para N\xC3O chamar: a foto estar ileg\xEDvel ou o valor total amb\xEDguo. A\xED pergunte \u2014 e",
+  "pergunte s\xF3 isso, sem descrever o resto."
+].join(" ");
+var OPEN_DRAFT = {
+  id: "financial.receipt.open-draft",
+  name: "openPayableDraft",
+  description: 'Opens the "new payable" form pre-filled with what was read from a receipt photo. Call this as soon as you can read an amount \u2014 it is how a receipt turns into a record, and describing the receipt in prose instead leaves the person with a sentence and no form. Writes nothing: the person reviews the form and saves it. Send ONLY fields the receipt actually states \u2014 omit anything you would be guessing at.',
+  icon: "ReceiptText",
+  mode: "read",
+  execution: { plane: "client" },
+  category: "Finance",
+  role: "finance",
+  parameters: {
+    type: "object",
+    properties: {
+      supplier: {
+        type: "string",
+        description: 'Quem RECEBEU o dinheiro, se o papel nomear. Cuidado: "Recebi de" e "a import\xE2ncia de" n\xE3o s\xE3o nomes \u2014 a primeira \xE9 quem pagou e a segunda \xE9 o valor por extenso. Um recibo de t\xE1xi normalmente n\xE3o tem fornecedor nenhum: omita em vez de inventar.'
+      },
+      amount: {
+        type: "string",
+        description: 'O valor total COPIADO LETRA POR LETRA do papel, com a pontua\xE7\xE3o que estiver l\xE1: "50,00", "1.234,56", "R$ 89,90". N\xC3O converta para n\xFAmero e n\xE3o tire a v\xEDrgula \u2014 quem l\xEA a pontua\xE7\xE3o \xE9 o aplicativo, que sabe a moeda do pa\xEDs.'
+      },
+      amountInWords: {
+        type: "string",
+        description: 'O valor POR EXTENSO, se o papel escrever ("CINQUENTA REAIS", "cento e vinte reais e cinquenta centavos"). Copie as palavras como est\xE3o. Num recibo manuscrito \xE9 ele que desempata: os algarismos costumam vir com um tra\xE7o entre reais e centavos ("50|00"), que n\xE3o \xE9 v\xEDrgula nenhuma.'
+      },
+      date: {
+        type: "string",
+        description: 'A data do documento como est\xE1 escrita ("20/01/2022", "2022-01-20"). Omita se o papel n\xE3o diz.'
+      },
+      description: {
+        type: "string",
+        description: 'O que foi pago, em poucas palavras \u2014 \xE9 o nome do item na conta. Um recibo quase sempre diz ("presta\xE7\xE3o de servi\xE7o de t\xE1xi", "insumos de padaria"). Sem ele a conta nasce como "Sem descri\xE7\xE3o", que n\xE3o diz nada a quem for conferir depois.'
+      },
+      notes: {
+        type: "string",
+        description: "Todo o RESTO que est\xE1 escrito e n\xE3o coube nos campos acima: itiner\xE1rio, placa, n\xFAmero do documento, condi\xE7\xF5es, nome de quem assinou. Vai para as observa\xE7\xF5es da conta, que \xE9 onde a pessoa procura o que o papel dizia. Copie o que leu; n\xE3o resuma em uma palavra. N\xC3O repita aqui o que j\xE1 foi para `date`, `amount` ou `description` \u2014 o resto significa o resto."
+      }
+    },
+    required: ["amount"]
+  }
+};
+var RECEIVABLE_RECEIPT_INTRO = {
+  role: "finance",
+  persona: "Leitor de notas e comprovantes",
+  pitch: "Envie a nota que voc\xEA emitiu e eu preencho a conta a receber.",
+  description: "Leio o que est\xE1 no documento \u2014 cliente, valor, data, n\xFAmero e chave da NF-e \u2014, digo o que entendi e abro a conta a receber j\xE1 preenchida para voc\xEA conferir. N\xE3o gravo nada sozinho: quem confirma \xE9 voc\xEA.",
+  suggestions: [
+    { label: "O que voc\xEA consegue ler de uma nota fiscal?" },
+    { label: "E se a foto estiver torta ou escura?" }
+  ]
+};
+var RECEIVABLE_RECEIPT_INSTRUCTIONS = [
+  "The person will send a PHOTO or PDF of a document for money they are going to RECEIVE: usually an NF-e/NFS-e",
+  "they ISSUED to a customer, or a receipt they gave. Read it and extract only what is written on it.",
+  "End the turn by CALLING `openReceivableDraft` with what you read. Describing the document in text opens nothing.",
+  "Do not announce that you will open it \u2014 open it. Talk to the person in Brazilian Portuguese.",
+  "THE COUNTERPARTY IS THE CUSTOMER. On an NF-e the person issued, the EMITENTE (issuer) is the person's own",
+  "company: never send it as the customer. Send the DESTINAT\xC1RIO / TOMADOR (recipient) name in `customer`.",
+  'On a receipt, the customer is the one who PAID ("Recebi de ..."). Without a clear customer name, omit `customer`.',
+  'Copy `amount` exactly as printed ("1.234,56"), never converted \u2014 the app parses the punctuation.',
+  "If the paper spells the amount out in words, copy it into `amountInWords`.",
+  "If it is an NF-e, copy the note NUMBER into `fiscalNumber` and the 44-digit ACCESS KEY (chave de acesso) into",
+  "`accessKey`, digits only. Omit either one when the paper does not show it.",
+  "Use `date` for the issue date, `description` for what was sold, and `notes` for anything else written that has",
+  "no field of its own. Do not invent fields the paper does not answer.",
+  "The only reason NOT to call is an illegible photo or an ambiguous total: then ask only that."
+].join(" ");
+var OPEN_RECEIVABLE_DRAFT = {
+  id: "financial.receipt.open-receivable-draft",
+  name: "openReceivableDraft",
+  description: 'Opens the "new receivable" form pre-filled with what was read from an issued invoice (NF-e) or receipt. Call this as soon as you can read an amount. Writes nothing: the person reviews the form and saves it. Send ONLY fields the document actually states \u2014 omit anything you would be guessing at.',
+  icon: "ReceiptText",
+  mode: "read",
+  execution: { plane: "client" },
+  category: "Finance",
+  role: "finance",
+  parameters: {
+    type: "object",
+    properties: {
+      customer: {
+        type: "string",
+        description: `Who OWES / PAID the money: the DESTINAT\xC1RIO or TOMADOR on an NF-e, or "Recebi de ..." on a receipt. NEVER the EMITENTE of an NF-e \u2014 that is the person's own company. Omit when not named.`
+      },
+      amount: {
+        type: "string",
+        description: 'The total COPIED as printed, punctuation included ("50,00", "1.234,56"). Do not convert it.'
+      },
+      amountInWords: {
+        type: "string",
+        description: "The amount spelled out in words, if the paper writes it. Copy the words as they are."
+      },
+      date: {
+        type: "string",
+        description: 'The issue date as written ("20/01/2026", "2026-01-20"). Omit if absent.'
+      },
+      description: {
+        type: "string",
+        description: "What was sold or provided, in a few words. It becomes the item name on the receivable."
+      },
+      fiscalNumber: {
+        type: "string",
+        description: 'The NF-e / NFS-e number (e.g. "1234" or "000.001.234"), when the document is a fiscal note.'
+      },
+      accessKey: {
+        type: "string",
+        description: 'The NF-e 44-digit access key ("chave de acesso"), when printed. Digits only.'
+      },
+      notes: {
+        type: "string",
+        description: "Everything ELSE written that has no field above. Do not repeat the amount, date, description, number or key."
+      }
+    },
+    required: ["amount"]
+  }
+};
+function parseAccessKey(raw) {
+  if (typeof raw !== "string") return void 0;
+  const digits = raw.replace(/\D/g, "");
+  return digits.length === 44 ? digits : void 0;
+}
+function parseReceiptAmount(raw) {
+  if (typeof raw === "number") return Number.isFinite(raw) && raw > 0 ? raw : null;
+  if (typeof raw !== "string") return null;
+  const text2 = raw.replace(/[^\d.,-]/g, "").trim();
+  if (!text2 || !/\d/.test(text2)) return null;
+  const lastComma = text2.lastIndexOf(",");
+  const lastDot = text2.lastIndexOf(".");
+  const cut = Math.max(lastComma, lastDot);
+  let normalized;
+  if (cut < 0) {
+    normalized = text2;
+  } else {
+    const decimals = text2.length - cut - 1;
+    normalized = decimals === 3 ? text2.replace(/[.,]/g, "") : `${text2.slice(0, cut).replace(/[.,]/g, "")}.${text2.slice(cut + 1)}`;
+  }
+  const value = Number(normalized);
+  return Number.isFinite(value) && value > 0 ? value : null;
+}
+function parseReceiptDate(raw) {
+  const text2 = typeof raw === "string" ? raw.trim() : "";
+  if (!text2) return void 0;
+  if (/^\d{4}-\d{2}-\d{2}$/.test(text2)) return isRealDate(text2) ? text2 : void 0;
+  const br = text2.match(/^(\d{1,2})[/.-](\d{1,2})[/.-](\d{2}|\d{4})$/);
+  if (!br) return void 0;
+  const [, d, m, y] = br;
+  const year = y.length === 2 ? `20${y}` : y;
+  const iso = `${year}-${m.padStart(2, "0")}-${d.padStart(2, "0")}`;
+  return isRealDate(iso) ? iso : void 0;
+}
+function findDateIn(text2) {
+  if (typeof text2 !== "string") return void 0;
+  return text2.match(/\b\d{1,2}[/.-]\d{1,2}[/.-](?:\d{4}|\d{2})\b/)?.[0];
+}
+function isRealDate(iso) {
+  const [y, m, d] = iso.split("-").map(Number);
+  const date = new Date(Date.UTC(y, m - 1, d));
+  return date.getUTCFullYear() === y && date.getUTCMonth() === m - 1 && date.getUTCDate() === d;
+}
+var pending = null;
+function consumePayableDraft(direction) {
+  const draft = pending;
+  pending = null;
+  if (draft && direction && (draft.direction ?? "debit") !== direction) return null;
+  return draft;
+}
+var lastPhoto;
+function rememberReceiptPhoto(dataUrl) {
+  lastPhoto = dataUrl;
+}
+function lastReceiptPhoto() {
+  return lastPhoto;
+}
+function readAmount(args) {
+  if (typeof args.amount !== "string") {
+    return {
+      ok: false,
+      error: "amount_must_be_literal",
+      message: 'Send `amount` as the TEXT printed on the receipt, punctuation included ("50,00", "1.234,56") \u2014 never as a number. A decimal comma is a thousands separator in English, so converting it yourself turns fifty into five thousand. Read the paper again and resend.'
+    };
+  }
+  const figures = parseReceiptAmount(args.amount);
+  const spelled = parseAmountInWords(args.amountInWords);
+  const amount = spelled ?? figures;
+  if (amount === null) {
+    return {
+      ok: false,
+      error: "invalid_amount",
+      message: "That is not a readable amount. If the total is illegible on the photo, ask the person."
+    };
+  }
+  return { ok: true, amount, spelled, figures };
+}
+function trimmed(value) {
+  const s = typeof value === "string" ? value.trim() : "";
+  return s || void 0;
+}
+function createReceivableReceiptTools({ onDraft, getReceiptUrl }) {
+  return [
+    {
+      tool: OPEN_RECEIVABLE_DRAFT,
+      // The payable path's `rememberedDocument` is NOT read here: it is a
+      // supplier-side reading, and seeding a receivable from it would bring the
+      // issuer back as the counterparty.
+      execute: async (args) => {
+        const read = readAmount(args);
+        if (!read.ok) return read;
+        const accessKey = parseAccessKey(args.accessKey);
+        const notes = [
+          trimmed(args.notes),
+          accessKey ? `Chave de acesso NF-e: ${accessKey}` : void 0
+        ].filter(Boolean).join(" \xB7 ") || void 0;
+        pending = {
+          direction: "credit",
+          amount: read.amount,
+          customer: trimmed(args.customer),
+          description: trimmed(args.description),
+          fiscalNumber: trimmed(args.fiscalNumber),
+          accessKey,
+          notes,
+          date: parseReceiptDate(args.date) ?? parseReceiptDate(findDateIn(args.notes)),
+          receiptUrl: getReceiptUrl()
+        };
+        onDraft();
+        revealPage();
+        return {
+          ok: true,
+          opened: true,
+          ...read.spelled !== null && read.figures !== null && Math.abs(read.spelled - read.figures) > 5e-3 ? {
+            amountFromWords: read.spelled,
+            amountFromFigures: read.figures,
+            note: `The figures looked like ${read.figures} and the words say ${read.spelled}. The words were used \u2014 tell the person.`
+          } : {},
+          filled: Object.entries(pending).filter(([, v]) => v !== void 0 && v !== "").map(([k]) => k)
+        };
+      }
+    }
+  ];
+}
+function createReceiptTools({ onDraft, getReceiptUrl = lastReceiptPhoto, direction = "payable" }) {
+  if (direction === "receivable") return createReceivableReceiptTools({ onDraft, getReceiptUrl });
+  return [
+    {
+      tool: OPEN_DRAFT,
+      execute: async (args) => {
+        const read = rememberedDocument();
+        if (read && read.total !== void 0) {
+          pending = {
+            amount: read.total,
+            ...read.items.length ? { items: read.items } : {},
+            ...read.shipping === void 0 ? {} : { shipping: read.shipping },
+            supplier: text(args.supplier) ?? void 0,
+            description: text(args.description) ?? void 0,
+            notes: [
+              text(args.notes),
+              read.orderRef ? `Pedido: ${read.orderRef}` : null,
+              read.deliveryDate ? `Entrega: ${read.deliveryDate}` : null
+            ].filter(Boolean).join(" \xB7 ") || void 0,
+            date: read.documentDate ?? parseReceiptDate(args.date),
+            receiptUrl: getReceiptUrl()
+          };
+          onDraft();
+          revealPage();
+          return {
+            ok: true,
+            opened: true,
+            fromDocument: true,
+            items: read.items.length,
+            total: read.total,
+            message: `O cadastro abriu com o que foi LIDO do documento \u2014 ${read.items.length || 1} linha(s), total ${read.total}. Diga isso em UMA frase e pare. N\xE3o repita os valores campo a campo e N\xC3O os recalcule: a pessoa est\xE1 olhando para eles.`
+          };
+        }
+        if (typeof args.amount !== "string") {
+          return {
+            ok: false,
+            error: "amount_must_be_literal",
+            message: 'Send `amount` as the TEXT printed on the receipt, punctuation included ("50,00", "1.234,56") \u2014 never as a number. A decimal comma is a thousands separator in English, so converting it yourself turns fifty into five thousand. Read the paper again and resend.'
+          };
+        }
+        const figures = parseReceiptAmount(args.amount);
+        const spelled = parseAmountInWords(args.amountInWords);
+        const amount = spelled ?? figures;
+        if (amount === null) {
+          return {
+            ok: false,
+            error: "invalid_amount",
+            message: "That is not a readable amount. If the total is illegible on the photo, ask the person."
+          };
+        }
+        const text2 = (value) => {
+          const s = typeof value === "string" ? value.trim() : "";
+          return s || void 0;
+        };
+        const isoDate = parseReceiptDate(args.date) ?? parseReceiptDate(findDateIn(args.notes));
+        pending = {
+          amount,
+          supplier: text2(args.supplier),
+          description: text2(args.description),
+          notes: text2(args.notes),
+          date: isoDate,
+          receiptUrl: getReceiptUrl()
+        };
+        onDraft();
+        revealPage();
+        return {
+          ok: true,
+          opened: true,
+          // Divergiram: o formulário abriu com o extenso, e quem assina merece
+          // saber que os algarismos diziam outra coisa.
+          ...spelled !== null && figures !== null && Math.abs(spelled - figures) > 5e-3 ? {
+            amountFromWords: spelled,
+            amountFromFigures: figures,
+            note: `Os algarismos pareciam ${figures} e o extenso diz ${spelled}. Usei o extenso, que \xE9 o que vale num recibo \u2014 diga isso \xE0 pessoa.`
+          } : {},
+          filled: Object.entries(pending).filter(([, v]) => v !== void 0 && v !== "").map(([k]) => k)
+        };
+      }
+    }
+  ];
+}
+function startReceiptCapture(labels) {
+  rememberReceiptPhoto(void 0);
+  askAI({ hint: labels.ask, intro: labels.direction === "receivable" ? RECEIVABLE_RECEIPT_INTRO : RECEIPT_INTRO });
+  requestChatUpload({
+    label: labels.uploadLabel,
+    description: labels.uploadHint,
+    accept: "image/*,application/pdf",
+    capture: "environment",
+    onFiles: async (files) => {
+      const photo = files[0];
+      if (!photo) return;
+      if (photo.type.startsWith("image/")) {
+        const inline = await toInlineFile(photo);
+        rememberReceiptPhoto(`data:${inline.mime};base64,${inline.data}`);
+      }
+      useChatStore.getState().queuePrompt(labels.prompt, [photo]);
+    }
+  });
+}
+var PAYABLE_INSTRUCTIONS = [
+  'Uma "conta a pagar" \xE9 uma DESPESA com um FORNECEDOR \u2014 quem a empresa deve. Para registrar uma,',
+  "chame `createPayable`. NUNCA use `createRecord` em `financial:payment-methods` para isso: aquele",
+  "registro configura como os CLIENTES pagam a empresa (bandeira, taxa, parcelamento), e um",
+  "fornecedor cadastrado l\xE1 n\xE3o vira conta nenhuma \u2014 vira lixo na configura\xE7\xE3o da loja.",
+  "Se a pessoa mandar a FOTO de um recibo ou de uma nota, leia a imagem e use o que est\xE1 escrito",
+  "nela. Uma foto n\xE3o tem colunas: nunca proponha importa\xE7\xE3o para ela.",
+  "Num pedido ou nota com TABELA, leia a tabela LINHA A LINHA e mande todas em `items` \u2014 c\xF3digo,",
+  'descri\xE7\xE3o, quantidade e pre\xE7o unit\xE1rio de cada uma. Uma linha gen\xE9rica de "servi\xE7o prestado" com',
+  "o total dentro perde o pedido inteiro. O FRETE \xE9 campo pr\xF3prio (`shipping`), n\xE3o some ao produto.",
+  "`amount` \xE9 sempre o TOTAL do rodap\xE9 (com frete), nunca o subtotal e nunca o total de uma linha.",
+  'Capture tamb\xE9m "M\xE9todo de pagamento:" quando impresso, o N\xDAMERO DO PEDIDO ("Pedido: #164223") e a',
+  "data de ENTREGA \u2014 pedido e entrega v\xE3o em `notes`, que \xE9 onde a pessoa procura o que o papel dizia.",
+  'Se o texto trouxer uma linha como "[c\xF3digo Pix copia-e-cola \u2014 valor embutido: X]", aquilo \xE9 o',
+  "c\xF3digo do pagamento: X confirma o total, e os d\xEDgitos em volta N\xC3O s\xE3o pre\xE7os.",
+  '"Expira em" de um c\xF3digo Pix \xE9 a validade do C\xD3DIGO, n\xE3o o vencimento da conta. Um pedido pago \xE0',
+  "vista n\xE3o tem vencimento: deixe `dueDate` de fora e o formul\xE1rio pergunta. Data chutada custa uma",
+  "cobran\xE7a; campo vazio custa um toque.",
+  "LEU UM PAPEL? PASSO 0 \xE9 `resolvePayableContext`, ANTES de escrever qualquer coisa. Extraia TUDO o",
+  "que est\xE1 escrito \u2014 fornecedor, CNPJ, o que foi comprado, forma de pagamento, bandeira e final do",
+  "cart\xE3o, datas, valores \u2014 e mande para conferir contra o que este neg\xF3cio j\xE1 tem. Ele responde o",
+  "que existe e o que falta, sem gravar nada. Diga o resultado em uma linha curta por depend\xEAncia e",
+  "resolva as que faltam NA ORDEM que ele devolve: fornecedor, forma de pagamento, depois a conta,",
+  "depois a baixa. Se voltar um candidato parecido, PERGUNTE se \xE9 o mesmo \u2014 n\xE3o cadastre de novo.",
+  'Valor vai COPIADO como est\xE1 escrito ("50,00", "1.234,56"), nunca convertido \u2014 a v\xEDrgula \xE9',
+  "decimal em portugu\xEAs, e convert\xEA-la voc\xEA mesmo j\xE1 transformou cinquenta reais em cinco mil.",
+  "N\xE3o entreviste a pessoa campo a campo. Mande o que ela disse e chame a ferramenta: o que abre",
+  "\xE9 um FORMUL\xC1RIO edit\xE1vel, e o que faltar ela preenche ali \u2014 em um toque, olhando os campos.",
+  "Uma conta a pagar tem TR\xCAS passos, cada um confirmado pela pessoa: (1) o fornecedor, (2) o t\xEDtulo,",
+  "(3) o pagamento \u2014 e o terceiro s\xF3 existe se a conta J\xC1 foi paga. Se o recibo ou a pessoa disser",
+  'que j\xE1 pagou ("pago hoje", "paguei no Pix"), mande `paid: true`; a ferramenta cuida da ordem.',
+  "Quando faltar saber COMO foi pago, a ferramenta PERGUNTA com as op\xE7\xF5es do pr\xF3prio neg\xF3cio na tela.",
+  "N\xE3o repita as op\xE7\xF5es em texto e n\xE3o escolha por ela: espere a resposta e ent\xE3o chame",
+  "`registerPayablePayment` com o id que ela tocou.",
+  "REGRA DE PRECED\xCANCIA: se o cadastro de conta a pagar estiver ABERTO na tela com um rascunho (veja",
+  '"Tela aberta agora"), ele \xE9 a conta em curso. Complete-o com `fillPayableDraft` e salve com',
+  "`submitPayableDraft`. `createPayable` \xE9 s\xF3 para quando N\xC3O h\xE1 rascunho aberto \u2014 cham\xE1-la com o",
+  "formul\xE1rio na tela cria uma segunda conta e deixa a pessoa num rascunho \xF3rf\xE3o.",
+  "Depois de lan\xE7ar, a tela da conta abre sozinha \u2014 \xE9 o normal e n\xE3o precisa ser anunciado. Mande",
+  "`redirect: false` s\xF3 quando levar a pessoa embora atrapalharia: v\xE1rias contas em sequ\xEAncia, ou",
+  "algu\xE9m no meio de outra tarefa que s\xF3 passou a conta de lado.",
+  '"Marca como pago", "paguei", "foi pago" sobre uma conta que VOC\xCA acabou de lan\xE7ar \xE9 sempre',
+  "`registerPayablePayment` com o invoiceId daquela conta \u2014 NUNCA `createPayable` de novo. Lan\xE7ar a",
+  "mesma despesa duas vezes \xE9 dinheiro contado em dobro, e desfazer isso \xE9 trabalho de concilia\xE7\xE3o."
+].join(" ");
+var CREATE_PAYABLE = {
+  id: "financial.create-payable",
+  name: "createPayable",
+  description: 'Records a BILL THE BUSINESS OWES a supplier (conta a pagar, despesa, boleto, invoice from a vendor). This is the tool for "lan\xE7ar/salvar uma conta a pagar", "paguei o fornecedor X", "recibo de despesa". It walks a CHECKLIST, one confirmable step at a time: (1) the supplier \u2014 found by name or created as a supplier contact, (2) the bill itself. Each step opens an EDITABLE FORM pre-filled with what you send and writes nothing until the person confirms it \u2014 so call it as soon as you have an amount and let the forms ask for the rest. If the receipt says it was ALREADY PAID ("pago hoje", "paguei via Pix"), set `paid: true`: step (3) is the payment, and this tool will either ask HOW it was paid or hand you off to `registerPayablePayment`. Send ONLY what you were actually told or could read; omit anything you would be guessing at. When the bill came off a receipt/photo/PDF, call `resolvePayableContext` FIRST and settle the missing dependencies it reports before calling this. A document with a TABLE goes in row by row through `items` (plus `shipping` for frete): the lines are reconciled against `amount`, and a mismatch comes back to be asked about rather than silently trusted. DO NOT use this when a payable form is already open on screen (a draft read from a receipt or PDF): that draft is the bill in progress \u2014 use `fillPayableDraft` and `submitPayableDraft` instead, or this writes a second, duplicate bill and strands the person on a draft that no longer means anything.',
+  icon: "ReceiptText",
+  mode: "persist",
+  execution: { plane: "client" },
+  // O guard é desta ferramenta: ela abre o próprio cartão de confirmação, que é
+  // um formulário. O cartão genérico do loop seria um segundo "tem certeza?"
+  // antes do formulário — duas perguntas para uma decisão.
+  requiresConfirmation: false,
+  category: "Finance",
+  role: "finance",
+  permission: { feature: "financial", action: "create" },
+  limitKey: "movements_month",
+  parameters: {
+    type: "object",
+    properties: {
+      supplier: {
+        type: "string",
+        description: 'Quem RECEBE o dinheiro \u2014 o fornecedor, a empresa, o prestador. \xC9 um NOME de quem foi pago ("Printi", "Padaria do Z\xE9"). N\xE3o \xE9 o que foi comprado nem o valor por extenso.'
+      },
+      amount: {
+        type: "string",
+        description: 'O valor TOTAL da conta \u2014 o que vai ser pago, incluindo frete. Num pedido \xE9 o "Total" do rodap\xE9, nunca o subtotal e nunca o total de uma linha. COPIADO LETRA POR LETRA, com a pontua\xE7\xE3o que estiver escrita: "50,00", "1.234,56", "R$ 89,90". N\xC3O converta para n\xFAmero e n\xE3o tire a v\xEDrgula \u2014 quem l\xEA a pontua\xE7\xE3o \xE9 o aplicativo, que sabe a moeda do pa\xEDs.'
+      },
+      amountInWords: {
+        type: "string",
+        description: 'O valor POR EXTENSO, quando o papel escrever ("CINQUENTA REAIS"). Num recibo manuscrito \xE9 ele que desempata os algarismos. Copie as palavras como est\xE3o.'
+      },
+      dueDate: {
+        type: "string",
+        description: 'O VENCIMENTO, como est\xE1 escrito ("20/01/2026", "2026-01-20"). Omita se ningu\xE9m disse \u2014 o formul\xE1rio pergunta. Uma data de vencimento chutada custa uma confer\xEAncia inteira.'
+      },
+      date: {
+        type: "string",
+        description: 'A data do DOCUMENTO (quando a compra aconteceu), se souber. "hoje" \xE9 hoje.'
+      },
+      description: {
+        type: "string",
+        description: 'O que foi comprado ou pago, em poucas palavras \u2014 \xE9 o nome da linha da conta ("cart\xF5es de visita", "insumos de padaria"). Sem ela a conta nasce sem dizer o que \xE9.'
+      },
+      items: {
+        type: "array",
+        description: 'As LINHAS da nota, uma por linha da tabela \u2014 leia a tabela linha a linha e copie todas. Um pedido de tr\xEAs produtos vira tr\xEAs linhas aqui, n\xE3o uma linha gen\xE9rica de "servi\xE7o prestado": \xE9 assim que a conta diz depois o que foi comprado. Omita quando o papel n\xE3o tem tabela (um recibo de t\xE1xi \xE9 uma linha s\xF3, e a\xED basta `description`).',
+        items: {
+          type: "object",
+          properties: {
+            description: { type: "string", description: "O que \xE9 a linha, como est\xE1 escrito (c\xF3digo + nome)." },
+            quantity: { type: "number", description: "A quantidade da linha. 1 quando a tabela n\xE3o diz." },
+            unitPrice: {
+              type: "string",
+              description: 'O pre\xE7o UNIT\xC1RIO copiado letra por letra ("47,90"), n\xE3o o total da linha e n\xE3o convertido.'
+            }
+          },
+          required: ["description", "unitPrice"]
+        }
+      },
+      shipping: {
+        type: "string",
+        description: 'O FRETE, copiado como est\xE1 escrito ("52,19"), quando o papel o cobra em separado. Vira uma linha pr\xF3pria na conta \u2014 somado a um produto ele desapareceria dentro do pre\xE7o dele.'
+      },
+      notes: {
+        type: "string",
+        description: 'Todo o RESTO que foi dito e n\xE3o coube nos campos acima: N\xDAMERO DO PEDIDO ou do documento ("Pedido: #164223"), data de entrega, condi\xE7\xF5es, para qual projeto. \xC9 onde a pessoa vai procurar o que o papel dizia. N\xC3O repita aqui o que j\xE1 foi para os outros campos.'
+      },
+      paid: {
+        type: "boolean",
+        description: 'true quando a conta J\xC1 FOI PAGA \u2014 "pago hoje", "paguei via Pix", um recibo quitado. Uma conta paga tem um terceiro passo: registrar o pagamento. N\xE3o marque true por um boleto ou uma nota que ainda vai vencer.'
+      },
+      paymentMethod: {
+        type: "string",
+        description: 'COMO foi pago, se a pessoa disse ("Pix", "dinheiro", "cart\xE3o de cr\xE9dito"). N\xE3o chute: sem isto a ferramenta PERGUNTA, oferecendo as formas que este neg\xF3cio aceita.'
+      },
+      paymentDate: {
+        type: "string",
+        description: 'QUANDO foi pago, se disserem. "pago hoje" \xE9 hoje.'
+      },
+      redirect: {
+        type: "boolean",
+        description: "Levar a pessoa at\xE9 a conta rec\xE9m-criada (default: true). Deixe true no caso normal \u2014 quem acabou de lan\xE7ar uma conta quer v\xEA-la. Mande FALSE quando levar embora atrapalharia: ela est\xE1 lan\xE7ando V\xC1RIAS contas em sequ\xEAncia, est\xE1 no meio de outra tarefa (uma tela de cadastro, uma concilia\xE7\xE3o) e s\xF3 passou a conta de lado, ou pediu explicitamente para ficar onde est\xE1. Com false a conta \xE9 criada do mesmo jeito e o link volta na resposta."
+      }
+    },
+    // `amount` deixa de ser obrigatório SÓ porque o passo 0 pode tê-lo lido: sem
+    // leitura guardada a ferramenta recusa do mesmo jeito, com a mesma mensagem.
+    required: []
+  }
+};
+var REGISTER_PAYMENT = {
+  id: "financial.register-payable-payment",
+  name: "registerPayablePayment",
+  description: "Step 3 of the payable checklist: registers that a bill WAS PAID \u2014 the money leaving, with its method and date. Call it with the `invoiceId` a previous `createPayable` returned, and the `method` the person chose (send the option id when they tapped one). Opens an editable confirmation before writing. Use it whenever a bill already recorded turns out to be settled; never to create the bill itself.",
+  icon: "BadgeDollarSign",
+  mode: "persist",
+  execution: { plane: "client" },
+  requiresConfirmation: false,
+  category: "Finance",
+  role: "finance",
+  permission: { feature: "financial", action: "update" },
+  parameters: {
+    type: "object",
+    properties: {
+      invoiceId: { type: "string", description: "Id da conta a pagar, devolvido por createPayable." },
+      method: {
+        type: "string",
+        description: 'A forma de pagamento \u2014 o id da op\xE7\xE3o que a pessoa tocou, ou o nome dela ("Pix", "Dinheiro").'
+      },
+      paymentDate: { type: "string", description: "A data do pagamento. Omita para hoje." }
+    },
+    required: ["invoiceId"]
+  }
+};
+var OPEN_FULL_FORM = {
+  id: "financial.open-payable-form",
+  name: "openPayableForm",
+  description: 'Opens the full "new payable" screen, empty or pre-filled, for a bill that needs more than a one-line entry: several installments, a receipt to attach, a ledger account or cost centre. Writes nothing. Prefer `createPayable` for an ordinary single bill \u2014 this one is the long form.',
+  icon: "FilePlus",
+  mode: "read",
+  execution: { plane: "client" },
+  category: "Finance",
+  role: "finance",
+  permission: { feature: "financial", action: "create" },
+  parameters: { type: "object", properties: {} }
+};
+function supplierRef(id, label) {
+  if (!resolveEntityRoute("person", "supplier")) return {};
+  return { ref: { id, label, archetype: "person:supplier" } };
+}
+async function resolveSupplier(lookup, name) {
+  const wanted = name.trim().toLowerCase();
+  const hits = await lookup.search(name).catch(() => []);
+  const exact = hits.find((r) => r.label.trim().toLowerCase() === wanted);
+  if (exact) return { ok: true, id: exact.id, name: exact.label, created: false };
+  if (!lookup.create) return { ok: true, name, created: false };
+  const decision = await useChatStore.getState().requestConfirmation({
+    id: `supplier-${Date.now()}`,
+    toolName: "createPayable",
+    title: "Novo fornecedor",
+    params: { name },
+    plane: "client",
+    scope: "financial:supplier",
+    scopeLabel: "Cadastrar fornecedor",
+    fields: [
+      { key: "name", label: "Nome", type: "text", required: true },
+      { key: "document_number", label: "CNPJ / CPF", type: "text" },
+      { key: "phone", label: "Telefone", type: "text" },
+      { key: "email", label: "E-mail", type: "text" }
+    ]
+  });
+  if (!decision.approved) return { ok: false, cancelled: true };
+  const draft = { ...{ name }, ...decision.values ?? {} };
+  const finalName = text(draft.name) ?? name;
+  const made = await lookup.create({
+    ...draft,
+    name: finalName
+  });
+  return { ok: true, id: made.id, name: made.label, created: true };
+}
+async function paymentOptions(provider) {
+  const types = await provider.getPaymentMethodTypes().catch(() => []);
+  return types.filter((t) => t.isActive !== false).map((t) => ({
+    id: t.id,
+    label: t.name,
+    transactionType: t.transactionType,
+    allowedAccountTypes: t.allowedAccountTypes
+  }));
+}
+var ACCOUNT_TYPES_FOR_TX = {
+  cash: ["cash_physical", "cash_session"],
+  credit_card: ["card_receivable_credit"],
+  debit_card: ["card_receivable_debit"],
+  pix: ["bank"],
+  bank_transfer: ["bank"],
+  boleto: ["bank"],
+  check: ["bank"],
+  voucher: ["bank"]
+};
+async function eligibleAccounts(provider, method) {
+  const accounts = (await provider.getBankAccounts().catch(() => [])).filter((a) => a.isActive !== false);
+  const allowed = method.allowedAccountTypes?.length ? method.allowedAccountTypes : ACCOUNT_TYPES_FOR_TX[method.transactionType ?? ""];
+  if (!allowed) return accounts;
+  return accounts.filter((a) => allowed.includes(a.accountType));
+}
+function matchPaymentOption(options, raw) {
+  const wanted = typeof raw === "string" ? raw.trim().toLowerCase() : "";
+  if (!wanted) return null;
+  return options.find((o) => o.id.toLowerCase() === wanted) ?? options.find((o) => o.label.toLowerCase() === wanted) ?? options.find((o) => o.label.toLowerCase().includes(wanted) || wanted.includes(o.label.toLowerCase())) ?? null;
+}
+async function settlePayable(provider, input) {
+  const schedule = await provider.getMovements({
+    invoiceId: input.invoiceId,
+    direction: "debit",
+    status: "pending"
+  });
+  const bill = schedule.data.find((m) => m.movementKind === "bill");
+  if (!bill) {
+    return {
+      ok: false,
+      error: "no_open_bill",
+      message: "That bill has no open installment \u2014 it may already be settled. Say so and stop."
+    };
+  }
+  const invoice = await provider.getInvoiceById(input.invoiceId).catch(() => null);
+  const money = (n) => formatCurrency(n, input.currency ?? "BRL");
+  const invoiceLabel = [
+    invoice?.fiscalNumber ? `#${invoice.fiscalNumber}` : null,
+    invoice?.contactName ?? null,
+    money(bill.amount)
+  ].filter(Boolean).join(" \u2014 ") || money(bill.amount);
+  const needsAccount = input.method.transactionType !== "cash";
+  const accounts = needsAccount ? await eligibleAccounts(provider, input.method) : [];
+  if (needsAccount && !accounts.length) {
+    return {
+      ok: false,
+      error: "no_eligible_account",
+      message: `The bill is recorded but NOT settled: this business has no account that can settle a ${input.method.label} payment. Say that, and that it has to be registered from the payables screen.`
+    };
+  }
+  const onlyAccount = accounts.length === 1 ? accounts[0] : void 0;
+  const paymentDate = parseReceiptDate(input.paymentDate) ?? today();
+  const decision = await useChatStore.getState().requestConfirmation({
+    id: `payment-${bill.id}`,
+    toolName: "registerPayablePayment",
+    title: "Registrar pagamento",
+    params: {
+      invoice: invoiceLabel,
+      method: input.method.label,
+      accountId: onlyAccount?.id,
+      paymentDate,
+      amount: bill.amount
+    },
+    plane: "client",
+    scope: "financial:payment",
+    scopeLabel: "Registrar pagamento",
+    fields: [
+      // Qual conta está sendo quitada, por extenso e primeiro. Só de leitura:
+      // é a identidade do que se assina, não um campo a editar.
+      { key: "invoice", label: "Conta a pagar", type: "text", readOnly: true },
+      { key: "method", label: "Forma de pagamento", type: "text", required: true, readOnly: true },
+      ...needsAccount ? [{
+        key: "accountId",
+        label: "Conta de sa\xEDda",
+        type: "select",
+        required: true,
+        options: accounts.map((a) => ({ value: a.id, label: a.name }))
+      }] : [],
+      { key: "paymentDate", label: "Data do pagamento", type: "date", required: true },
+      { key: "amount", label: "Valor pago", type: "number", required: true, min: 0 }
+    ]
+  });
+  if (!decision.approved) {
+    return {
+      ok: false,
+      cancelled: true,
+      reason: "user_declined",
+      message: "The bill is recorded but NOT settled \u2014 the payment step was declined. Say exactly that."
+    };
+  }
+  const values = { paymentDate, amount: bill.amount, accountId: onlyAccount?.id, ...decision.values ?? {} };
+  const accountId = typeof values.accountId === "string" && values.accountId ? values.accountId : void 0;
+  if (needsAccount && !accountId) {
+    return {
+      ok: false,
+      error: "no_account",
+      message: "NOTHING WAS SETTLED. The form came back with no outgoing account \u2014 do not say it was paid."
+    };
+  }
+  await provider.payMovement({
+    movementId: bill.id,
+    amount: parseReceiptAmount(values.amount) ?? bill.amount,
+    paymentDate: parseReceiptDate(values.paymentDate) ?? paymentDate,
+    paymentMethodTypeId: input.method.id,
+    bankAccountId: accountId
+  });
+  return {
+    ok: true,
+    settled: true,
+    invoiceId: input.invoiceId,
+    movementId: bill.id,
+    method: input.method.label,
+    account: accounts.find((a) => a.id === accountId)?.name,
+    paymentDate: parseReceiptDate(values.paymentDate) ?? paymentDate,
+    // O botão que abre a conta quitada. `path` existe para exatamente isto —
+    // uma tela de plugin que o mapa de rotas por arquétipo não sabe resolver.
+    ref: {
+      id: input.invoiceId,
+      label: invoiceLabel,
+      path: `/financial/payables/${input.invoiceId}`
+    },
+    message: `Pago via ${input.method.label}. Diga em UMA frase que a conta foi lan\xE7ada e quitada, e pare.`
+  };
+}
+var recentPayables = [];
+var RECENT_WINDOW_MS = 10 * 60 * 1e3;
+function rememberPayable(entry) {
+  recentPayables = [...recentPayables.filter((p) => p.invoiceId !== entry.invoiceId), entry].slice(-10);
+}
+function findRecentPayable(supplier, amount) {
+  const now = Date.now();
+  recentPayables = recentPayables.filter((p) => now - p.at < RECENT_WINDOW_MS);
+  const wanted = supplier.trim().toLowerCase();
+  return recentPayables.find(
+    (p) => p.supplier.trim().toLowerCase() === wanted && Math.abs(p.amount - amount) < 5e-3
+  );
+}
+function clearRecentPayables() {
+  recentPayables = [];
+}
+function asChoiceCards(choices) {
+  const usable = choices.filter((c) => c.options.length >= 2);
+  return usable.length ? { kind: "record_choice", choices: usable } : {};
+}
+function gapChoices(input) {
+  const questions = [];
+  const { supplierName, supplier, method, account } = input;
+  if (supplier.status !== "found" && supplierName) {
+    const candidates = supplier.candidates ?? [];
+    questions.push({
+      id: "supplier",
+      question: candidates.length ? `"${supplierName}" n\xE3o est\xE1 cadastrado. \xC9 algum destes?` : `"${supplierName}" ainda n\xE3o est\xE1 cadastrado. Cadastrar agora?`,
+      options: [
+        // Os parecidos PRIMEIRO: a razão de eles existirem é evitar o
+        // duplicado, então a opção de criar não pode ser a mais fácil de tocar.
+        ...candidates.slice(0, 4).map((c) => ({
+          id: `supplier:${c.id}`,
+          label: c.name,
+          meta: c.why
+        })),
+        { id: "supplier:create", label: `Criar fornecedor "${supplierName}"` },
+        { id: "supplier:cancel", label: "Cancelar" }
+      ]
+    });
+  }
+  if (method.status !== "found") {
+    const available = method.available ?? [];
+    questions.push({
+      id: "method",
+      question: method.spoken ? `O papel diz "${String(method.spoken)}", que n\xE3o est\xE1 cadastrado. Qual forma corresponde?` : "Como esta conta foi (ou vai ser) paga?",
+      options: [
+        ...available.slice(0, 5).map((o) => ({ id: `method:${o.id}`, label: o.label })),
+        { id: "method:none", label: "Deixar em aberto" }
+      ]
+    });
+  }
+  if (account.status === "ambiguous") {
+    const options = account.options ?? [];
+    questions.push({
+      id: "account",
+      question: account.cardLast4 ? `Nenhuma conta cadastrada tem o final ${String(account.cardLast4)}. De qual conta saiu?` : "De qual conta o dinheiro saiu?",
+      options: [
+        ...options.slice(0, 5).map((o) => ({ id: `account:${o.id}`, label: o.name })),
+        { id: "account:skip", label: "Decidir na hora de pagar" }
+      ]
+    });
+  }
+  return questions;
+}
+function askHowItWasPaid(invoiceId, options) {
+  return {
+    kind: "record_choice",
+    choices: [{
+      id: `payment-method-${invoiceId}`,
+      question: "Foi pago como?",
+      options
+    }],
+    invoiceId,
+    nextStep: "registerPayablePayment",
+    message: `The bill is recorded but NOT yet settled. The person is being asked HOW it was paid \u2014 the options are on screen. Do not list them again in prose and do not guess one. When they answer, call registerPayablePayment with invoiceId "${invoiceId}" and the option id they chose.`
+  };
+}
+function createPayableTools({ config, provider }) {
+  const lookup = config.contactLookup ?? createArchetypeLookup({
+    archetype: "person",
+    kind: "supplier",
+    createKinds: ["supplier", "staff", "customer"],
+    kindLabels: { supplier: "Fornecedor", customer: "Cliente", staff: "Funcion\xE1rio" }
+  });
+  return [
+    {
+      tool: RESOLVE_CONTEXT,
+      execute: async (args) => {
+        consumePayableDraft();
+        const supplierName = text(args.supplier);
+        const supplier = supplierName ? await findSupplier(lookup, supplierName, args.supplierDocument) : { status: "missing", candidates: [] };
+        const method = await findMethod(provider, args);
+        const account = await findAccount(provider, method, args.cardLast4);
+        const gaps = [
+          supplier.status !== "found" ? "supplier" : null,
+          method.status !== "found" ? "method" : null,
+          account.status === "ambiguous" || account.status === "missing" ? "account" : null
+        ].filter(Boolean);
+        const choices = gapChoices({ supplierName, supplier, method, account });
+        const document = normalizeDocument(args);
+        rememberDocument(document, {
+          ...text(args.supplier) ? { source: text(args.supplier) } : {},
+          ...useChatStore.getState().conversationId ? { conversationId: useChatStore.getState().conversationId } : {}
+        });
+        return {
+          ok: true,
+          read: {
+            supplier: supplierName,
+            supplierDocument: onlyDigits(args.supplierDocument) || void 0,
+            paymentMethod: text(args.paymentMethod),
+            cardBrand: text(args.cardBrand),
+            cardLast4: lastFour(args.cardLast4) || void 0
+          },
+          supplier,
+          method,
+          account,
+          gaps,
+          document,
+          ...asChoiceCards(choices),
+          message: 'NOTHING WAS WRITTEN \u2014 this was a check. Tell the person the result as ONE short line per dependency, saying which already exist and which are missing (e.g. "Fornecedor Printi: ja existe - Pix: cadastrado - cartao final 4242: nao encontrei"). FIRST say what you READ, in one line, from `document`: how many items, the total, the method, the order ref, and the dates \u2014 and when `document.dueDate` is null say plainly there is no due date on the paper (\xE0 vista) and that the form will ask. If `document.reconciles` is false and there are items and a total, say the numbers do not add up and ask, instead of choosing one. The extraction is SAVED: when you call createPayable next, you may omit items/shipping/total/dates entirely \u2014 it reuses exactly what was read here. Do NOT re-read the document to fill them in again; re-reading from memory is where wrong numbers come from. ' + (choices.length ? "The open questions are ALREADY ON SCREEN as tappable buttons \u2014 do NOT repeat the options in prose and do NOT ask the person to type an answer. End your reply after the checklist and WAIT for the tap. When they answer, the option id says what to do: `supplier:create` means create the supplier under the name in `read.supplier` (call createPayable and its supplier step will confirm it), `supplier:<uuid>` means use that existing one, `method:<id>` is the payment method, `account:<id>` the outgoing account, and anything `:cancel` means stop. " : "Then continue with createPayable for the bill, and the payment. ") + "Never invent a value the paper did not state."
+        };
+      }
+    },
+    {
+      tool: OPEN_FULL_FORM,
+      execute: async () => {
+        adminNavigateTo("/financial/payables/new");
+        return { ok: true, opened: "/financial/payables/new" };
+      }
+    },
+    {
+      tool: CREATE_PAYABLE,
+      execute: async (args) => {
+        if (hasLivePayableDraft()) {
+          return {
+            ok: false,
+            error: "draft_open",
+            message: "NOTHING WAS WRITTEN, and no second bill was created. The payable form is OPEN ON SCREEN with the draft this conversation has been building \u2014 that draft IS this bill. Continue in it: use `fillPayableDraft` for what is missing and `submitPayableDraft` to save. Do not call createPayable again while that form is open."
+          };
+        }
+        const remembered = rememberedDocument();
+        if (args.amount === void 0 && remembered?.total !== void 0) {
+          args = { ...args, amount: String(remembered.total) };
+        }
+        if (typeof args.amount !== "string") {
+          return {
+            ok: false,
+            error: "amount_must_be_literal",
+            message: 'Send `amount` as the TEXT that was written, punctuation included ("50,00", "1.234,56") \u2014 never as a number. A decimal comma is a thousands separator in English, so converting it yourself turns fifty into five thousand. Resend the literal.'
+          };
+        }
+        const figures = parseReceiptAmount(args.amount);
+        const spelled = parseAmountInWords(args.amountInWords);
+        const amount = spelled ?? figures;
+        if (amount === null) {
+          return {
+            ok: false,
+            error: "invalid_amount",
+            message: "That is not a readable amount. If the total is illegible or was never said, ask the person."
+          };
+        }
+        const lines = args.items === void 0 && remembered?.items.length ? { items: remembered.items, error: void 0 } : parseLineItems(args.items);
+        if (lines.error) return { ok: false, error: "invalid_items", message: lines.error };
+        const shipping = args.shipping === void 0 ? remembered?.shipping ?? null : parseReceiptAmount(args.shipping);
+        const lineSum = round2(lines.items.reduce((s, i) => s + i.quantity * i.unitPrice, 0));
+        const computed = round2(lineSum + (shipping ?? 0));
+        const candidates = [
+          { value: amount, from: "argumento" },
+          ...remembered?.total !== void 0 ? [{ value: remembered.total, from: "leitura" }] : []
+        ];
+        const agreed = lines.items.length ? candidates.find((c) => Math.abs(computed - c.value) <= 0.02) : candidates[0];
+        if (lines.items.length && !agreed) {
+          return {
+            ok: false,
+            error: "total_mismatch",
+            lineSum,
+            shipping: shipping ?? void 0,
+            computed,
+            total: amount,
+            ...remembered?.total !== void 0 ? { totalFromDocument: remembered.total } : {},
+            message: `NOTHING WAS WRITTEN. The lines do not add up to the total: the item(s) sum to ${lineSum}${shipping ? ` plus ${shipping} of shipping` : ""} = ${computed}, but the total given is ${amount}. Do NOT pick one of them and do not adjust a line to make it fit. Re-read the document \u2014 a line may have been missed, a quantity misread, or a discount or shipping line not captured. If the paper genuinely disagrees with itself, ask the person which is right.`
+          };
+        }
+        const reconciledTotal = agreed?.value ?? amount;
+        const correctedFromRead = agreed?.from === "leitura" && Math.abs(agreed.value - amount) > 5e-3;
+        const dueDate = parseReceiptDate(args.dueDate) ?? remembered?.dueDate ?? void 0;
+        const issueDate = parseReceiptDate(args.date) ?? remembered?.documentDate ?? parseReceiptDate(findDateIn(args.notes));
+        const params = { amount };
+        const supplierName = text(args.supplier);
+        if (supplierName) params.supplier = supplierName;
+        const description = text(args.description);
+        if (description) params.description = description;
+        if (dueDate) params.dueDate = dueDate;
+        if (issueDate) params.issueDate = issueDate;
+        const carried = [
+          remembered?.orderRef ? `Pedido: ${remembered.orderRef}` : null,
+          remembered?.deliveryDate ? `Entrega: ${remembered.deliveryDate}` : null
+        ].filter(Boolean).join(" \xB7 ");
+        const notes = text(args.notes) ?? (carried || void 0);
+        if (notes) params.notes = notes;
+        if (lines.items.length) {
+          params.items = lines.items.map((i) => `${i.quantity}\xD7 ${i.description} @ ${i.unitPrice}`).join(" \xB7 ");
+          params.amount = computed;
+        }
+        if (shipping) params.shipping = shipping;
+        if (supplierName) {
+          const already = findRecentPayable(supplierName, amount);
+          if (already) {
+            return {
+              ok: false,
+              error: "already_recorded",
+              invoiceId: already.invoiceId,
+              message: `NOTHING WAS WRITTEN and no second bill was created. The bill for ${supplierName} of ${amount} was ALREADY recorded in this conversation \u2014 its invoiceId is "${already.invoiceId}". If the person is saying it was PAID ("marca como pago", "paguei no Pix"), call registerPayablePayment with invoiceId "${already.invoiceId}". Only call createPayable again if this is genuinely a DIFFERENT bill, with a different amount or supplier.`
+            };
+          }
+        }
+        let supplier = null;
+        if (supplierName) {
+          const step = await resolveSupplier(lookup, supplierName);
+          if (!step.ok) {
+            return {
+              ok: false,
+              cancelled: true,
+              reason: "user_declined_supplier",
+              message: "NOTHING WAS WRITTEN. The person declined creating the supplier, so the bill has nobody to point at. Ask which existing supplier it belongs to \u2014 do not retry the same name."
+            };
+          }
+          supplier = { id: step.id, name: step.name, created: step.created };
+          params.supplier = step.name;
+        }
+        const decision = await useChatStore.getState().requestConfirmation({
+          id: `payable-${Date.now()}`,
+          toolName: "createPayable",
+          // Nomeia o que está sendo criado. Era `config.labels.payablesNew`,
+          // que é o rótulo da AÇÃO na sub-navegação ("New") — no topo de um
+          // cartão de confirmação ele dizia só "New" e não nomeava nada.
+          title: "Nova conta a pagar",
+          params,
+          plane: "client",
+          scope: "financial:payable",
+          scopeLabel: "Lan\xE7ar conta a pagar",
+          fields: [
+            { key: "supplier", label: "Fornecedor", type: "text", required: true },
+            { key: "description", label: "Descri\xE7\xE3o", type: "text", required: true },
+            // As linhas lidas da tabela, à vista e só de leitura: é o que a
+            // pessoa confere para saber se a leitura do papel bateu.
+            ...lines.items.length ? [{ key: "items", label: "Itens", type: "text", readOnly: true }] : [],
+            ...shipping ? [{ key: "shipping", label: "Frete", type: "number", readOnly: true }] : [],
+            // Com tabela lida, o valor É a soma conferida — editá-lo aqui o
+            // separaria das linhas, e o banco recusa uma fatura cujas parcelas
+            // não fecham com os itens. Sem tabela, ele continua editável.
+            {
+              key: "amount",
+              label: "Valor total",
+              type: "number",
+              required: true,
+              min: 0,
+              ...lines.items.length ? { readOnly: true } : {}
+            },
+            { key: "dueDate", label: "Vencimento", type: "date", required: true },
+            { key: "issueDate", label: "Data do documento", type: "date", default: today() },
+            { key: "notes", label: "Observa\xE7\xF5es", type: "text" }
+          ]
+        });
+        if (!decision.approved) return { ok: false, cancelled: true, reason: "user_declined" };
+        const values = { ...params, ...decision.values ?? {} };
+        const finalAmount = lines.items.length ? computed : parseReceiptAmount(values.amount) ?? amount;
+        const finalSupplier = text(values.supplier);
+        const finalDescription = text(values.description) ?? finalSupplier ?? "";
+        const finalDue = parseReceiptDate(values.dueDate);
+        const finalIssue = parseReceiptDate(values.issueDate) ?? today();
+        if (!finalSupplier || !finalDue) {
+          return {
+            ok: false,
+            error: "incomplete",
+            message: "NOTHING WAS WRITTEN. The form came back without a supplier or a due date \u2014 do not tell the user it worked."
+          };
+        }
+        let resolvedSupplier = supplier;
+        if (!resolvedSupplier || resolvedSupplier.name !== finalSupplier) {
+          const again = await resolveSupplier(lookup, finalSupplier);
+          if (!again.ok) {
+            return {
+              ok: false,
+              cancelled: true,
+              reason: "user_declined_supplier",
+              message: "NOTHING WAS WRITTEN. The supplier step was declined \u2014 ask which supplier this bill belongs to."
+            };
+          }
+          resolvedSupplier = { id: again.id, name: again.name, created: again.created };
+        }
+        const invoice = await provider.createInvoice({
+          direction: "debit",
+          invoiceDate: finalIssue,
+          contactId: resolvedSupplier.id,
+          contactName: resolvedSupplier.name,
+          observations: text(values.notes),
+          // A nota que o papel descreve, linha por linha. Sem tabela, a conta
+          // nasce com uma linha só — que é o que um recibo de táxi é. O FRETE é
+          // linha PRÓPRIA: somado ao preço de um produto ele sumiria dentro
+          // dele, e a conciliação com a transportadora não teria onde olhar.
+          items: [
+            ...lines.items.length ? lines.items.map((line) => ({
+              itemKind: "other",
+              description: line.description,
+              quantity: line.quantity,
+              unitPrice: line.unitPrice
+            })) : [{
+              itemKind: "other",
+              description: finalDescription,
+              quantity: 1,
+              unitPrice: round2(finalAmount - (shipping ?? 0))
+            }],
+            ...shipping ? [{ itemKind: "other", description: "Frete", quantity: 1, unitPrice: shipping }] : []
+          ],
+          installments: [{
+            direction: "debit",
+            movementKind: "bill",
+            amount: finalAmount,
+            dueDate: finalDue,
+            installmentNumber: 1
+          }]
+        });
+        const id = invoice?.id;
+        if (id) {
+          rememberPayable({ invoiceId: id, supplier: resolvedSupplier.name, amount: finalAmount, at: Date.now() });
+        }
+        consumePayableDraft();
+        const drift = spelled !== null && figures !== null && Math.abs(spelled - figures) > 5e-3 ? { note: `Os algarismos pareciam ${figures} e o extenso diz ${spelled}. Usei o extenso.` } : {};
+        const invoicePath = id ? `/financial/payables/${id}` : null;
+        const redirected = invoicePath !== null && args.redirect !== false;
+        if (redirected) {
+          adminNavigateTo(invoicePath);
+          revealPage();
+        }
+        const invoiceLink = invoicePath ? { ref: { id, label: `${resolvedSupplier.name} \u2014 ${finalDescription}`, path: invoicePath } } : {};
+        if (args.paid === true && id) {
+          const options = await paymentOptions(provider);
+          const chosen = matchPaymentOption(options, args.paymentMethod);
+          if (!chosen) {
+            if (options.length >= 2) {
+              return {
+                ...askHowItWasPaid(id, options),
+                supplier: resolvedSupplier.name,
+                supplierCreated: resolvedSupplier.created,
+                amount: finalAmount,
+                openedInvoice: redirected,
+                ...drift
+              };
+            }
+            return {
+              ok: true,
+              invoiceId: id,
+              settled: false,
+              supplier: resolvedSupplier.name,
+              amount: finalAmount,
+              dueDate: finalDue,
+              openedInvoice: redirected,
+              ...invoiceLink,
+              message: "A conta foi lan\xE7ada, mas o pagamento N\xC3O foi registrado: este neg\xF3cio n\xE3o tem formas de pagamento cadastradas para escolher. Diga isso e ofere\xE7a registrar a baixa pela tela.",
+              ...drift
+            };
+          }
+          const settled = await settlePayable(provider, {
+            invoiceId: id,
+            method: chosen,
+            paymentDate: typeof args.paymentDate === "string" ? args.paymentDate : void 0,
+            currency: config.currency?.code
+          });
+          return {
+            ...settled,
+            invoiceId: id,
+            supplier: resolvedSupplier.name,
+            supplierCreated: resolvedSupplier.created,
+            amount: finalAmount,
+            openedInvoice: redirected,
+            ...drift
+          };
+        }
+        return {
+          ok: true,
+          invoiceId: id,
+          settled: false,
+          supplier: resolvedSupplier.name,
+          supplierCreated: resolvedSupplier.created,
+          amount: finalAmount,
+          dueDate: finalDue,
+          openedInvoice: redirected,
+          ...lines.items.length ? { itemsWritten: lines.items.length } : {},
+          // Dito, nunca silencioso: se o total que veio na chamada perdeu os
+          // centavos e o da leitura fechou com as linhas, quem escreveu foi a
+          // leitura — e quem confere merece saber disso.
+          ...correctedFromRead ? {
+            correctedTotal: {
+              sent: amount,
+              written: reconciledTotal,
+              why: "o total enviado n\xE3o fechava com as linhas; o lido do documento fechou"
+            }
+          } : {},
+          ...shipping ? { shipping } : {},
+          // A CONTA é o destino principal — é o que a pessoa acabou de criar.
+          ...invoiceLink,
+          // O fornecedor vai como segundo botão, e só onde existe tela para ele
+          // (ver supplierRef): `extractRecordLinks` lê `ref` e `record.ref`.
+          ...resolvedSupplier.id ? { record: supplierRef(resolvedSupplier.id, resolvedSupplier.name) } : {},
+          // O que fazer DEPOIS, dito com o id dentro. Sem esta linha, "marca
+          // como pago no pix hoje" na mensagem seguinte virou uma SEGUNDA conta
+          // a pagar: o modelo tinha a ferramenta de baixa e nenhuma frase
+          // ligando-a a esta fatura.
+          message: `A conta a pagar de ${resolvedSupplier.name} foi lan\xE7ada (invoiceId "${id}"), em aberto. ` + (resolvedSupplier.created ? "O fornecedor foi cadastrado agora. " : "") + (redirected ? "A tela da conta J\xC1 foi aberta \u2014 n\xE3o ofere\xE7a abri-la. " : "") + `Diga isso em UMA frase e pare \u2014 n\xE3o repita os campos, a pessoa acabou de conferi-los. IMPORTANTE: se a pessoa disser depois que esta conta foi paga ("marca como pago", "paguei no Pix", "foi pago hoje"), chame registerPayablePayment com invoiceId "${id}". N\xC3O chame createPayable de novo \u2014 isso criaria uma segunda conta para a mesma despesa.`,
+          ...drift
+        };
+      }
+    },
+    {
+      tool: REGISTER_PAYMENT,
+      execute: async (args) => {
+        const invoiceId = typeof args.invoiceId === "string" ? args.invoiceId : "";
+        if (!invoiceId) {
+          return {
+            ok: false,
+            error: "missing_invoice",
+            message: "Which bill? Pass the `invoiceId` that createPayable returned."
+          };
+        }
+        const options = await paymentOptions(provider);
+        const chosen = matchPaymentOption(options, args.method);
+        if (!chosen) {
+          if (options.length < 2) {
+            return {
+              ok: false,
+              error: "no_payment_methods",
+              message: "This business has no payment methods to choose from. Say so instead of guessing one."
+            };
+          }
+          return askHowItWasPaid(invoiceId, options);
+        }
+        return settlePayable(provider, {
+          invoiceId,
+          method: chosen,
+          paymentDate: typeof args.paymentDate === "string" ? args.paymentDate : void 0,
+          currency: config.currency?.code
+        });
+      }
+    }
+  ];
+}
+var liveDraft = null;
+function hasLivePayableDraft() {
+  return liveDraft !== null;
+}
+var COMPANY_NOISE = /* @__PURE__ */ new Set([
+  "ltda",
+  "ltd",
+  "me",
+  "epp",
+  "eireli",
+  "sa",
+  "mei",
+  "cia",
+  "ei",
+  "inc",
+  "comercio",
+  "servicos",
+  "industria",
+  "do",
+  "da",
+  "de",
+  "dos",
+  "das",
+  "e"
+]);
+function normalizeCompanyName(raw) {
+  if (typeof raw !== "string") return "";
+  return raw.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w && !COMPANY_NOISE.has(w)).join(" ").trim();
+}
+function onlyDigits(raw) {
+  return typeof raw === "string" ? raw.replace(/\D/g, "") : "";
+}
+function lastFour(raw) {
+  const digits = onlyDigits(raw);
+  return digits.length >= 4 ? digits.slice(-4) : "";
+}
+async function findSupplier(lookup, rawName, rawDocument) {
+  const wanted = normalizeCompanyName(rawName);
+  const doc = onlyDigits(rawDocument);
+  if (!wanted) return { status: "missing", candidates: [] };
+  const core = wanted.split(" ")[0] ?? wanted;
+  const seen = /* @__PURE__ */ new Map();
+  for (const query of core === wanted ? [core] : [core, wanted]) {
+    for (const hit of await lookup.search(query).catch(() => [])) {
+      const row = hit.data ?? {};
+      seen.set(hit.id, {
+        id: hit.id,
+        name: hit.label,
+        document: onlyDigits(row.document_number) || void 0,
+        why: ""
+      });
+    }
+  }
+  const all = [...seen.values()];
+  if (doc) {
+    const byDoc = all.find((c) => c.document && c.document === doc);
+    if (byDoc) return { status: "found", match: { ...byDoc, why: "mesmo CNPJ/CPF" }, candidates: [] };
+  }
+  const exact = all.filter((c) => normalizeCompanyName(c.name) === wanted);
+  if (exact.length === 1) {
+    const only = exact[0];
+    if (doc && only.document && only.document !== doc) {
+      return {
+        status: "ambiguous",
+        candidates: [{ ...only, why: "mesmo nome, mas o CNPJ do papel \xE9 outro" }]
+      };
+    }
+    return { status: "found", match: { ...only, why: "nome id\xEAntico" }, candidates: [] };
+  }
+  const near = all.map((c) => {
+    const n = normalizeCompanyName(c.name);
+    if (!n) return null;
+    if (n === wanted) return { ...c, why: "nome id\xEAntico" };
+    if (n.startsWith(wanted) || wanted.startsWith(n)) return { ...c, why: "nome contido" };
+    const shared = n.split(" ").filter((w) => wanted.split(" ").includes(w));
+    return shared.length ? { ...c, why: `parte do nome em comum (${shared.join(" ")})` } : null;
+  }).filter((c) => c !== null).slice(0, 5);
+  return { status: near.length ? "ambiguous" : "missing", candidates: near };
+}
+async function findMethod(provider, args) {
+  const types = await paymentOptions(provider);
+  const spoken = [args.paymentMethod, args.cardBrand].filter((v) => typeof v === "string" && !!v.trim());
+  const card = lastFour(args.cardLast4);
+  const looksLikeCard = !!(card || args.cardBrand);
+  let match = matchPaymentOption(types, args.paymentMethod);
+  if (!match && looksLikeCard) {
+    match = types.find((t) => t.transactionType === "credit_card") ?? null;
+  }
+  const configured = (await provider.getPaymentMethods().catch(() => [])).filter((m) => m.isActive !== false);
+  const namedMethod = configured.find((m) => {
+    const n = normalizeCompanyName(m.name);
+    return !!n && spoken.some((s) => {
+      const w = normalizeCompanyName(s);
+      return !!w && (n === w || n.includes(w) || w.includes(n));
+    });
+  });
+  if (!match) {
+    return {
+      status: "missing",
+      spoken: spoken.join(" ") || void 0,
+      cardLast4: card || void 0,
+      available: types.map((t) => ({ id: t.id, label: t.label })),
+      hint: "This business has no payment method matching what the paper says. ASK which of the available ones it maps to, or offer to add it in Settings (createRecord on financial:payment-methods is the right tool for THAT, and only that). Never silently pick one."
+    };
+  }
+  return {
+    status: "found",
+    id: match.id,
+    label: match.label,
+    transactionType: match.transactionType,
+    ...namedMethod ? { configuredMethod: { id: namedMethod.id, name: namedMethod.name } } : {},
+    ...card ? { cardLast4: card } : {}
+  };
+}
+async function findAccount(provider, method, rawLast4) {
+  if (method.status !== "found") {
+    return { status: "blocked", hint: "Resolve the payment method first \u2014 the eligible accounts depend on it." };
+  }
+  if (method.transactionType === "cash") {
+    return {
+      status: "not_applicable",
+      hint: "Cash settles through the open cash session, not an account \u2014 nothing to choose."
+    };
+  }
+  const accounts = await eligibleAccounts(provider, {
+    id: String(method.id),
+    label: String(method.label),
+    transactionType: method.transactionType
+  });
+  const card = lastFour(rawLast4);
+  const byCard = card ? accounts.find((a) => lastFour(a.accountNumber) === card || a.name.includes(card)) : void 0;
+  if (byCard) return { status: "found", id: byCard.id, name: byCard.name, why: `final ${card}` };
+  if (!accounts.length) {
+    return {
+      status: "missing",
+      hint: `No account can settle a ${String(method.label)} payment. Say so \u2014 it has to be created in Settings.`
+    };
+  }
+  if (card) {
+    return {
+      status: "ambiguous",
+      cardLast4: card,
+      note: `o papel diz final ${card} e nenhuma conta cadastrada tem esse final`,
+      options: accounts.map((a) => ({ id: a.id, name: a.name })),
+      hint: `ASK whether the card ending ${card} is one of these accounts, or whether it still has to be registered. Do not assume it is the only eligible one.`
+    };
+  }
+  if (accounts.length === 1) {
+    return { status: "found", id: accounts[0].id, name: accounts[0].name, why: "\xFAnica conta eleg\xEDvel" };
+  }
+  return {
+    status: "ambiguous",
+    ...card ? { cardLast4: card, note: `nenhuma conta bate com o final ${card}` } : {},
+    options: accounts.map((a) => ({ id: a.id, name: a.name })),
+    hint: "Ask which account the money left. Do not pick one."
+  };
+}
+var RESOLVE_CONTEXT = {
+  id: "financial.resolve-payable-context",
+  name: "resolvePayableContext",
+  description: "STEP 0, BEFORE writing anything: checks what a receipt names against what this business actually has. Call it as soon as you have read a receipt/photo/PDF, with EVERYTHING the paper says \u2014 supplier, its CNPJ/CPF if printed, the payment method, the card brand and last 4 digits if printed. Returns, for each dependency, whether it already exists here (fuzzy-matched on name and CNPJ, so the same supplier is never created twice), is ambiguous, or is missing \u2014 plus the candidates to choose from. Writes NOTHING. Report the result as a short checklist and then resolve the gaps IN ORDER: supplier first, then the payment method, then the bill (createPayable), then the payment.",
+  icon: "ListChecks",
+  mode: "read",
+  execution: { plane: "client" },
+  category: "Finance",
+  role: "finance",
+  permission: { feature: "financial", action: "read" },
+  parameters: {
+    type: "object",
+    properties: {
+      supplier: { type: "string", description: "O nome do fornecedor EXATAMENTE como est\xE1 escrito no papel." },
+      supplierDocument: { type: "string", description: "O CNPJ ou CPF impresso, se houver. Copie os d\xEDgitos." },
+      paymentMethod: {
+        type: "string",
+        description: 'Como o papel diz que foi pago ("PIX", "cart\xE3o de cr\xE9dito", "dinheiro", "boleto").'
+      },
+      cardBrand: { type: "string", description: 'A bandeira, se impressa ("Visa", "Mastercard", "Nubank").' },
+      cardLast4: { type: "string", description: 'Os quatro \xFAltimos d\xEDgitos do cart\xE3o, se impressos ("4242").' },
+      // O DOCUMENTO INTEIRO, lido UMA VEZ.
+      //
+      // Não é zelo: é onde a fabricação entrava. Extrair no passo 0 e extrair de
+      // novo no passo da conta são duas leituras do mesmo papel, e a segunda não
+      // tem o papel na frente — ela tem a memória da primeira, que é onde os
+      // números começam a escorregar. Lido aqui, normalizado aqui, conferido
+      // aqui, e as ferramentas seguintes CONSOMEM o que ficou guardado.
+      items: {
+        type: "array",
+        description: "As LINHAS da tabela do documento, uma por linha \u2014 leia linha a linha e copie TODAS.",
+        items: {
+          type: "object",
+          properties: {
+            description: { type: "string", description: "O que \xE9 a linha, como est\xE1 escrito." },
+            quantity: { type: "number", description: "A quantidade. 1 quando a tabela n\xE3o diz." },
+            unitPrice: { type: "string", description: 'Pre\xE7o UNIT\xC1RIO copiado ("47,90").' }
+          },
+          required: ["description", "unitPrice"]
+        }
+      },
+      shipping: { type: "string", description: 'O FRETE cobrado \xE0 parte, copiado ("52,19").' },
+      subtotal: { type: "string", description: 'O subtotal impresso, se houver ("1.437,00").' },
+      total: {
+        type: "string",
+        description: 'O TOTAL do rodap\xE9, copiado letra por letra ("1.489,19"). Com frete, sem converter.'
+      },
+      documentDate: { type: "string", description: 'A data do documento ("09/09/2026").' },
+      dueDate: {
+        type: "string",
+        description: 'O VENCIMENTO, s\xF3 se o papel disser. "Expira em" de um c\xF3digo Pix \xE9 a validade do C\xD3DIGO, n\xE3o vencimento: um pedido pago \xE0 vista n\xE3o tem, e a\xED se omite.'
+      },
+      paymentDate: { type: "string", description: "Quando foi pago, se o papel disser." },
+      orderRef: { type: "string", description: 'O n\xFAmero do pedido ou documento ("#164223").' },
+      deliveryDate: { type: "string", description: 'A data de entrega, se impressa ("11/09/2026").' }
+    }
+  }
+};
+var FILL_DRAFT = {
+  id: "financial.fill-payable-draft",
+  name: "fillPayableDraft",
+  description: "Fills a field of the payable form ALREADY OPEN on screen (the draft the person is looking at). Use this \u2014 not createPayable \u2014 whenever that form is open: it is the bill in progress, and writing a new one instead would leave the person staring at a draft that means nothing. Looks the supplier up by name and offers to create it when it does not exist yet. Saves nothing.",
+  icon: "PenLine",
+  mode: "read",
+  execution: { plane: "client" },
+  category: "Finance",
+  role: "finance",
+  parameters: {
+    type: "object",
+    properties: {
+      supplier: { type: "string", description: "O nome do fornecedor a colocar no rascunho." },
+      dueDate: { type: "string", description: 'O vencimento, como foi dito ("20/01/2026").' }
+    }
+  }
+};
+var SUBMIT_DRAFT = {
+  id: "financial.submit-payable-draft",
+  name: "submitPayableDraft",
+  description: `SAVES the payable form open on screen \u2014 the same thing the screen's save button does. This is how "salva", "pode salvar", "confirma" is answered while that form is open. Never call createPayable for a draft that is already on screen: that writes a second, duplicate bill.`,
+  icon: "Check",
+  mode: "persist",
+  execution: { plane: "client" },
+  requiresConfirmation: false,
+  category: "Finance",
+  role: "finance",
+  permission: { feature: "financial", action: "create" },
+  parameters: { type: "object", properties: {} }
+};
+function PayableDraftSurface({ config, draft }) {
+  const live = React.useRef(draft);
+  live.current = draft;
+  const lookup = React.useMemo(
+    () => config.contactLookup ?? createArchetypeLookup({
+      archetype: "person",
+      kind: "supplier",
+      createKinds: ["supplier", "staff", "customer"],
+      kindLabels: { supplier: "Fornecedor", customer: "Cliente", staff: "Funcion\xE1rio" }
+    }),
+    [config.contactLookup]
+  );
+  React.useEffect(() => {
+    liveDraft = {
+      describe: () => live.current.describe(),
+      setSupplier: (name, id) => live.current.setSupplier(name, id),
+      setDueDate: (iso) => live.current.setDueDate(iso),
+      submit: () => live.current.submit()
+    };
+    return () => {
+      liveDraft = null;
+    };
+  }, []);
+  const contribution = React.useMemo(() => ({
+    id: "financial.payables.draft",
+    pluginId: "financial",
+    role: "finance",
+    instructions: 'O cadastro de uma CONTA A PAGAR est\xE1 aberto na tela, com um rascunho que a pessoa est\xE1 conferindo. Enquanto ele estiver a\xED, ele \xC9 a conta em curso: use `fillPayableDraft` para completar o que falta e `submitPayableDraft` para salvar. N\xC3O chame `createPayable` \u2014 ela criaria uma segunda conta e deixaria a pessoa num rascunho \xF3rf\xE3o. O estado do rascunho est\xE1 em "Tela aberta agora".',
+    describe: () => {
+      const state = live.current.describe();
+      return {
+        title: "Cadastro \u2014 Conta a pagar (rascunho n\xE3o salvo)",
+        state: { screen: "/financial/payables/new", draft: state }
+      };
+    },
+    tools: [
+      {
+        tool: FILL_DRAFT,
+        execute: async (args) => {
+          const filled = [];
+          const dueDate = parseReceiptDate(args.dueDate);
+          if (dueDate) {
+            live.current.setDueDate(dueDate);
+            filled.push("dueDate");
+          }
+          const name = text(args.supplier);
+          if (name) {
+            const step = await resolveSupplier(lookup, name);
+            if (!step.ok) {
+              return {
+                ok: false,
+                cancelled: true,
+                reason: "user_declined_supplier",
+                message: "The supplier was not created, so the draft still has none. Ask which supplier it is."
+              };
+            }
+            live.current.setSupplier(step.name, step.id);
+            filled.push("supplier");
+          }
+          if (!filled.length) {
+            return { ok: false, error: "nothing_to_fill", message: "Send a supplier or a dueDate to fill in." };
+          }
+          return {
+            ok: true,
+            filled,
+            draft: live.current.describe(),
+            message: "O rascunho na tela foi preenchido \u2014 nada foi salvo ainda. Diga em UMA frase o que entrou e que basta confirmar. Quando a pessoa mandar salvar, chame submitPayableDraft."
+          };
+        }
+      },
+      {
+        tool: SUBMIT_DRAFT,
+        execute: async () => {
+          const before = live.current.describe();
+          if (!before.itemCount) {
+            return {
+              ok: false,
+              error: "empty_draft",
+              message: "NOTHING WAS SAVED. The draft has no line to bill. Say what is missing."
+            };
+          }
+          await live.current.submit();
+          return {
+            ok: true,
+            saved: true,
+            supplier: before.supplier,
+            total: before.total,
+            message: "A conta a pagar foi salva a partir do rascunho que estava na tela, e a ficha dela j\xE1 abriu. Diga isso em UMA frase e pare."
+          };
+        }
+      }
+    ]
+  }), [lookup]);
+  useAgentSurface(contribution);
+  return null;
+}
+function createFinancialAgentMount(deps) {
+  const FinancialAgentMount = () => {
+    const contribution = React.useMemo(() => ({
+      id: "financial.payables.global",
+      pluginId: "financial",
+      role: "finance",
+      instructions: PAYABLE_INSTRUCTIONS,
+      // Sem `describe`: esta superfície não é uma tela. O snapshot responde "o
+      // que está na tela agora", e um mount de shell que dissesse "Contas a
+      // pagar" mentiria em todas as outras rotas do app.
+      tools: createPayableTools(deps)
+    }), []);
+    useAgentSurface(contribution);
+    return null;
+  };
+  FinancialAgentMount.displayName = "FinancialAgentMount";
+  return FinancialAgentMount;
+}
+
+export { PAYABLE_INSTRUCTIONS, PayableDraftSurface, RECEIPT_INSTRUCTIONS, RECEIVABLE_RECEIPT_INSTRUCTIONS, clearRecentPayables, consumePayableDraft, createFinancialAgentMount, createPayableTools, createReceiptTools, hasLivePayableDraft, normalizeCompanyName, startReceiptCapture };
+//# sourceMappingURL=chunk-7VKJLBYY.js.map
+//# sourceMappingURL=chunk-7VKJLBYY.js.map