@arcforgelabs/flow 2026.11.5 → 2026.11.6

package/server/integrations/seazona/migrations/meta/_journal.json

@@ -57,6 +57,13 @@
       "when": 1792472936253,
       "tag": "0007_stage_moves",
       "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "7",
+      "when": 1794463203447,
+      "tag": "0008_order_remake",
+      "breakpoints": true
     }
   ]
 }

package/server/integrations/seazona/schema.js

@@ -74,6 +74,8 @@ export const seazonaOrders = pgTable('seazona_orders', {
   lines: jsonb('lines').notNull().default([]),
   subtotalCents: cents('subtotal_cents'),
   patientReference: text('patient_reference'),
+  // Seazona's isRemake on the order: a remake of earlier work.
+  remake: boolean('remake').notNull().default(false),
   // Issue #12: Seazona answered 404. The row and its history stay; the order
   // reads as "Deleted in Seazona" and is out of billing. A later successful
   // read clears it.

package/server/integrations/seazona/store.js

@@ -81,6 +81,20 @@ export async function touchSynced(db, mirror, keys, { at }) {
   await db.update(table).set({ lastSyncedAt: at }).where(inArray(table[key], keys));
 }
 
+// The remake flag of orders whose other list fields did not change, from the
+// list rows (`flags`, Map(id -> boolean)): no detail read is needed. A change
+// counts as a change of the order, so the billing feed reads it again.
+export async function syncRemakeFlags(db, flags, { at }) {
+  const ids = [...flags.keys()];
+  if (!ids.length) return 0;
+  const values = ids.map((id) => flags.get(id) === true);
+  const { rowCount } = await db.execute(sql`
+    update seazona_orders o set remake = f.remake, last_changed_at = ${at}
+    from unnest(${sql.param(ids)}::text[], ${sql.param(values)}::boolean[]) as f(id, remake)
+    where o.id = f.id and o.remake is distinct from f.remake`);
+  return rowCount ?? 0;
+}
+
 // Issue #12: Seazona answered 404. Keep the row and its history, mark it, and
 // refresh its sync time so it never comes first in the rotation again. An
 // order seen in a list but never stored is kept from that list row.

package/server/integrations/seazona/sweep.js

@@ -17,6 +17,7 @@ import {
   readOrderFailures,
   readQuarantinedRecords,
   recordRecordFailure,
+  syncRemakeFlags,
   touchSynced,
   upsertRecords,
 } from './store.js';
@@ -216,6 +217,8 @@ async function sweepOrderDay(ctx, day, progress, helpers, found) {
     }
   }
   await touchSynced(db, 'orders', unchanged, { at });
+  // The remake flag is on the list row: kept with no detail read.
+  await syncRemakeFlags(db, new Map(unchanged.map((id) => [id, listed.get(id)?.isRemake === true])), { at });
 
   // Held for this day, left out of the list, and not seen this cycle.
   for (const row of held) {

package/server/integrations/sentry/index.js

@@ -1,6 +1,6 @@
 import * as SentryNode from '@sentry/node';
 import { isReplitWorkspace } from '../../core/host.js';
-import { scrubSpan } from '../../ui/monitoring.js';
+import { scrubEvent, scrubSpan } from '../../ui/monitoring.js';
 
 // The Sentry adapter (docs/SENTRY.md). It sends the errors Flow logs, the
 // browser's errors and problem reports, and performance traces from both
@@ -48,6 +48,7 @@ export const SENTRY_SETUP = {
     { name: 'SENTRY_ENVIRONMENT', label: 'Environment', advanced: true, help: 'How Sentry labels this installation, for example production. Empty: production, or workspace in a Replit workspace.' },
     { name: 'SENTRY_CLIENT', label: 'Client', advanced: true, help: 'The name your support desk files this installation\'s reports under. Sent as the client tag. Empty: no client tag.' },
     { name: 'SENTRY_FEEDBACK', label: 'Report button', kind: 'onoff', default: 'on', help: 'On: everyone signed in can send a report, with a screenshot, to this Sentry project.' },
+    { name: 'SENTRY_SCREENSHOT', label: 'Screenshot', kind: 'onoff', default: 'off', help: 'On: a report can add a screenshot. A screenshot shows the screen as it is, with names and prices, so it is off by default.' },
     { name: 'SENTRY_REPLAY', label: 'Replay', kind: 'onoff', default: 'on', help: 'On: each report and each browser error keeps up to the last minute of the page, as a replay with every word hidden.' },
     { name: 'SENTRY_TRACES_SAMPLE_RATE', label: 'Traces', advanced: true, help: 'The share of clicks, page loads and requests timed, from 0 (off) to 1 (all). Empty: 0.2.' },
   ],
@@ -61,6 +62,7 @@ export function readSentrySettings(env) {
   // labelled apart so they never read as the live app's.
   const environment = String(env.SENTRY_ENVIRONMENT ?? '').trim() || (isReplitWorkspace(env) ? 'workspace' : 'production');
   const feedback = String(env.SENTRY_FEEDBACK ?? 'on').trim() !== 'off';
+  const screenshot = String(env.SENTRY_SCREENSHOT ?? 'off').trim() === 'on';
   const replay = String(env.SENTRY_REPLAY ?? 'on').trim() !== 'off';
   const rate = String(env.SENTRY_TRACES_SAMPLE_RATE ?? '').trim();
   const tracesSampleRate = rate === '' ? DEFAULT_TRACES_SAMPLE_RATE : Number(rate);
@@ -72,7 +74,7 @@ export function readSentrySettings(env) {
   // Every event says which product and, when set, which client it is from,
   // so one support desk can serve many installations.
   const tags = client ? { product: 'flow', client } : { product: 'flow' };
-  return { dsn, environment, feedback, replay, tracesSampleRate, tags };
+  return { dsn, environment, feedback, screenshot, replay, tracesSampleRate, tags };
 }
 
 // No trace for the host's health check: it is not a person waiting.
@@ -105,8 +107,10 @@ export function createSentryAdapter({ sdk = SentryNode, env: hostEnv = process.e
         environment: settings.environment,
         release: release ?? undefined,
         initialScope: { tags: settings.tags },
-        // Flow sends what it logs; no request bodies, cookies or IP addresses.
+        // Flow sends what it logs, with private words masked (scrubEvent);
+        // no request bodies, cookies or IP addresses.
         sendDefaultPii: false,
+        beforeSend: scrubEvent,
         // A request the browser traced keeps the browser's choice, so a
         // click and the server work it caused stay one trace.
         tracesSampler: ({ attributes, inheritOrSampleWith }) => (
@@ -139,12 +143,13 @@ export function createSentryAdapter({ sdk = SentryNode, env: hostEnv = process.e
       // meant for browsers.
       browserMonitoring() {
         if (!settings) return null;
-        const { tracesSampleRate, replay } = settings;
+        const { tracesSampleRate, replay, screenshot } = settings;
         return {
           dsn: settings.dsn,
           environment: settings.environment,
           release,
           feedback: settings.feedback,
+          screenshot,
           replay,
           tags: settings.tags,
           tracesSampleRate,

package/server/integrations/xero/catalogue.js

@@ -223,6 +223,46 @@ export async function itemsByCode(db, organisationId, codes) {
   return new Map(rows.map((row) => [row.code, itemRow(row)]));
 }
 
+// The Xero item each Flow price code sends as. A Flow item linked to a Xero
+// item (the price list's link, by Xero's ItemID, so a code changed in Xero
+// still finds it) sends as that item, under Xero's own code. A link whose
+// Xero item has left Xero's list is `linkMissing`: never fall back to the
+// Flow code then. A Flow item with no link sends as the Xero item with the
+// same code. Codes with neither are absent from the map.
+export async function xeroItemsForCodes(db, organisationId, codes) {
+  const wanted = [...new Set(codes.filter(Boolean))];
+  if (!wanted.length) return new Map();
+  const { rows } = await db.execute(sql`
+    select p.code as flow_code, l.external_id as link_id, x.*
+    from unnest(${sql.param(wanted)}::text[]) as w(code)
+    left join price_items p on p.organisation_id = ${organisationId} and p.code = w.code
+    left join lateral (
+      select external_id from price_item_links pl
+      where pl.organisation_id = ${organisationId} and pl.price_item_id = p.id and pl.system = 'xero'
+      order by pl.created_at desc limit 1) l on true
+    left join xero_items x on x.organisation_id = ${organisationId}
+      and (case when l.external_id is not null then x.xero_item_id = l.external_id else x.code = w.code end)`);
+  const found = new Map();
+  for (const row of rows) {
+    const code = row.flow_code;
+    if (!code) continue;
+    if (row.link_id && !row.xero_item_id) found.set(code, { linkMissing: true, xeroItemId: row.link_id });
+    else if (row.xero_item_id) found.set(code, { ...itemRow(row), linked: Boolean(row.link_id) });
+  }
+  // A code with no Flow price item (an older document) still matches by code.
+  const rest = wanted.filter((c) => !found.has(c));
+  if (rest.length) for (const [code, item] of await itemsByCode(db, organisationId, rest)) found.set(code, item);
+  return found;
+}
+
+// The Flow codes that send as a Xero item that sells: the rule field "Every
+// item is in accounting" (invoice-rules.js) reads them. A gone link, a
+// missing item and an item not set to be sold do not count.
+export async function sellingCodes(db, organisationId, codes) {
+  const items = await xeroItemsForCodes(db, organisationId, codes);
+  return [...items].filter(([, item]) => !item.linkMissing && item.isSold !== false).map(([code]) => code);
+}
+
 // The Xero contact for a Flow contact name: exactly one active contact with
 // the same name, or why not. A missing name can be created from the Flow
 // contact when that setting is on (create-contact.js). A doubled name is

package/server/integrations/xero/drafts.js

@@ -5,7 +5,7 @@ import { getInvoice, listInvoiceVersions } from '../../core/invoices.js';
 import { sendModeFor } from '../../core/invoicing-rules.js';
 import { contacts as flowContacts, invoices as flowInvoices, priceItems } from '../../db/schema.js';
 import { readConnection } from './connections.js';
-import { itemsByCode, lastSuccessfulSyncAt, matchContactFor, normaliseName } from './catalogue.js';
+import { lastSuccessfulSyncAt, xeroItemsForCodes, matchContactFor, normaliseName } from './catalogue.js';
 import { writesAllowed } from './settings.js';
 import { xeroError } from './client.js';
 import { withXeroLane } from './governor.js';
@@ -162,8 +162,19 @@ export function buildDraft(document, { settings, contact, items, sendMode = 'acc
       TaxType: settings.taxTypes[line.taxCode],
     };
     if (line.itemCode) {
-      if (items.has(line.itemCode)) out.ItemCode = line.itemCode;
-      else problems.push(problem('xero_item_missing', `Line ${line.position}: item ${line.itemCode} is not in Xero. Add it in Xero, then sync.`, { itemCode: line.itemCode, short: `${line.itemCode} not in Xero` }));
+      // The Xero item this Flow code sends as (catalogue.js, xeroItemsForCodes):
+      // the linked item under Xero's own code, else the same code.
+      const item = items.get(line.itemCode);
+      if (item?.linkMissing) {
+        problems.push(problem('xero_item_missing', `Line ${line.position}: item ${line.itemCode} is linked to a Xero item that is no longer in Xero. Link it again in Price list, then sync.`, { itemCode: line.itemCode, short: `${line.itemCode} link gone` }));
+      } else if (!item) {
+        problems.push(problem('xero_item_missing', `Line ${line.position}: item ${line.itemCode} is not in Xero. Add it in Xero, then sync.`, { itemCode: line.itemCode, short: `${line.itemCode} not in Xero` }));
+      } else if (item.isSold === false) {
+        problems.push(problem('xero_item_missing', `Line ${line.position}: Xero item ${item.code || line.itemCode} is not set to be sold. Turn on "I sell this item" in Xero, then sync.`, { itemCode: line.itemCode, short: `${item.code || line.itemCode} not sold in Xero` }));
+      } else {
+        out.ItemCode = item.code || line.itemCode;
+        if (settings.lineText === 'item' && item.name) out.Description = item.name;
+      }
     } else if (line.accountCode) {
       // A line with no item books to its own account, such as a surcharge.
       out.AccountCode = line.accountCode;
@@ -324,7 +335,7 @@ async function previewOne(db, runtime, organisationId, invoiceId) {
   const offerCreate = match.state === 'missing' && runtime.settings.createContacts && writesAllowed(runtime.settings);
   if (match.state === 'missing') problems.push(missingContact(document.contact.name, { offerCreate }));
   if (match.state === 'ambiguous') problems.push(twiceContact(document.contact.name));
-  const items = await itemsByCode(db, organisationId, document.lines.map((l) => l.itemCode));
+  const items = await xeroItemsForCodes(db, organisationId, document.lines.map((l) => l.itemCode));
   const sendMode = await sendModeFor(db, organisationId, invoice.contactId);
   const { draft, problems: lineProblems } = buildDraft(document, { settings: runtime.settings, contact: match.contact, items, sendMode });
   problems.push(...lineProblems);
@@ -509,7 +520,7 @@ async function pushOne(db, runtime, client, organisationId, invoiceId, { pushedB
     const found = match.state === 'missing' ? missingContact(document.contact.name, { offerCreate }) : twiceContact(document.contact.name);
     throw xeroError(found.code, found.message, { status: 409, short: found.short });
   }
-  const items = await itemsByCode(db, organisationId, document.lines.map((l) => l.itemCode));
+  const items = await xeroItemsForCodes(db, organisationId, document.lines.map((l) => l.itemCode));
   const sendMode = await sendModeFor(db, organisationId, invoice.contactId);
   const { draft, problems } = buildDraft(document, { settings: runtime.settings, contact: match.contact, items, sendMode });
   if (problems.length) throw xeroError(problems[0].code, problems.map((p) => p.message).join(' '), { status: 409, short: problems[0].short });

package/server/integrations/xero/index.js

@@ -7,6 +7,7 @@ import { deleteXeroInvoice } from './delete-invoice.js';
 import { createCustomer } from './create-contact.js';
 import { checkDrafts, documentFacts, pushInvoice, pushInvoices } from './drafts.js';
 import { readConnection } from './connections.js';
+import { lastSuccessfulSyncAt, sellingCodes } from './catalogue.js';
 import { createImportWorker } from './import.js';
 import { readPayments, xeroLiveCheck } from './ledger.js';
 import { findInvoices, listCustomers, listPriceItems, mirrorState } from './lookup.js';
@@ -166,6 +167,15 @@ export function createXeroAdapter({ runtime: given = null } = {}) {
       createCustomer: ({ organisationId, contactId, actor = null }) => createCustomer(database, current(), { organisationId, contactId, actor }),
       // Sales invoices from the mirror, with the mirror's state (lookup.js).
       findInvoices: ({ organisationId, ...query }) => findInvoices(database, organisationId, query),
+      // The Flow codes that send as a Xero item that sells (catalogue.js),
+      // for the invoice rule field "Every item is in accounting". Null while
+      // not connected or before the first item sync.
+      itemMatches: async ({ organisationId, codes = [] }) => {
+        const connection = await readConnection(database, organisationId);
+        if (!connection || connection.mode !== current().settings.mode) return null;
+        if (!(await lastSuccessfulSyncAt(database, organisationId))) return null;
+        return sellingCodes(database, organisationId, codes);
+      },
       // Xero items, from Flow's copy, for the price list (lookup.js).
       listPriceItems: ({ organisationId }) => listPriceItems(database, organisationId, { taxTypes: current().settings.taxTypes }),
     },

package/server/integrations/xero/lookup.js

@@ -107,7 +107,8 @@ function invoiceRow(r) {
 }
 
 // Sales invoices from the mirror, by any of: Xero ids, invoice numbers, the
-// Flow invoices Flow sent, or one customer within a date range. Answers the
+// Flow invoices Flow sent or the Xero import linked, or one customer within a
+// date range. Answers the
 // mirror's state with them, and the latest change time it holds.
 export async function findInvoices(db, organisationId, query = {}) {
   const { invoiceIds = [], numbers = [], references = [], flowInvoiceIds = [], contactId = null, from = null, to = null } = query;
@@ -127,9 +128,15 @@ export async function findInvoices(db, organisationId, query = {}) {
     select i.*, p.invoice_id as flow_invoice_id
     from xero_invoices i
     left join lateral (
-      select invoice_id from xero_invoice_pushes
-      where organisation_id = i.organisation_id and xero_invoice_id = i.xero_invoice_id
-      order by version desc limit 1
+      -- The Flow invoice this Xero invoice is: the one Flow sent it from,
+      -- else the one the Xero import linked or made from it.
+      select invoice_id from (
+        select invoice_id, 0 as pick, version from xero_invoice_pushes
+        where organisation_id = i.organisation_id and xero_invoice_id = i.xero_invoice_id
+        union all
+        select invoice_id, 1, 0 from xero_invoice_links
+        where organisation_id = i.organisation_id and xero_invoice_id = i.xero_invoice_id
+      ) f order by pick, version desc limit 1
     ) p on true
     where i.organisation_id = ${organisationId} and i.type = 'ACCREC'
       and (${sql.join(where, sql` or `)})

package/server/integrations/xero/settings.js

@@ -163,6 +163,8 @@ export function resolveXeroSettings(env = process.env) {
 
   const invoiceNumber = (readEnv(env, 'XERO_INVOICE_NUMBER') || 'xero').toLowerCase();
   if (!['xero', 'flow'].includes(invoiceNumber)) throw new Error('XERO_INVOICE_NUMBER must be "xero", "flow" or unset');
+  const lineText = (readEnv(env, 'XERO_LINE_TEXT') || 'flow').toLowerCase();
+  if (!['flow', 'item'].includes(lineText)) throw new Error('XERO_LINE_TEXT must be "flow", "item" or unset');
 
   return {
     mode,
@@ -184,6 +186,9 @@ export function resolveXeroSettings(env = process.env) {
     tracking: resolveTracking(env),
     defaultDueDays: readPositiveInteger(env, 'XERO_DEFAULT_DUE_DAYS', DEFAULT_DUE_DAYS),
     invoiceNumber,
+    // The text on each Xero line with an item: `flow` (default) the Flow
+    // line's own text; `item` the Xero item's name.
+    lineText,
     replayFixtures: readEnv(env, 'XERO_REPLAY_FIXTURES') || null,
     // Free text on Xero records (references, line descriptions) is the lab's
     // own data, and the Import matches on it. On unless the lab turns it off.

package/server/ui/monitoring.js

@@ -126,6 +126,62 @@ export function scrubRecordingEvent(event) {
   return { ...event, data: { ...event.data, payload: next } };
 }
 
+// Private data in an event's words. Flow's own lines name a step and a code;
+// the text they pass on from the database, Xero or Seazona can hold a name,
+// an email, an amount or a record id. Each becomes a placeholder, so the event
+// keeps the fault and drops the data, and the same fault with other records
+// is one issue in Sentry, not one issue per record.
+const TEXT_MASKS = [
+  [/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, '<email>'],
+  [/\b\d{4}-\d{2}-\d{2}(T[\d:.]+Z?)?\b/g, '<time>'],
+  [/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, '<id>'],
+  // A database's "Key (column)=(value)".
+  [/\(([^()\n]{1,200})\)=\(([^()\n]{0,200})\)/g, '(<field>)=(<value>)'],
+  // Quoted text: a contact, a reference, a file name. An apostrophe inside a
+  // word ("Flow's") is not a quote.
+  [/"[^"\n]{1,200}"|“[^”\n]{1,200}”|‘[^’\n]{1,200}’|(?<![\w'])'[^'\n]{1,200}'(?![\w'])/g, '<text>'],
+  [/[$£€]\s?\d[\d,]*(\.\d+)?|\b\d[\d,]*\.\d{2}\b/g, '<amount>'],
+  [/\b[A-Z]{2,6}-\d{2,}\b/g, '<ref>'],
+  [/\+?\d[\d ().-]{6,}\d/g, '<number>'],
+  [/\b\d{3,}\b/g, '<n>'],
+];
+// Only the address-like words: for what a person types in a problem report,
+// where a number can be the point of the report.
+const CONTACT_MASKS = TEXT_MASKS.slice(0, 1).concat([[/\+?\d[\d ()-]{8,}\d/g, '<number>']]);
+export function maskText(value, masks = TEXT_MASKS) {
+  if (typeof value !== 'string') return value;
+  return masks.reduce((text, [pattern, mark]) => text.replace(pattern, mark), value);
+}
+
+// Every event before it leaves Flow, on the server and in the browser
+// (beforeSend). The words are masked (maskText); a request keeps its path,
+// never its body, query string, cookies or headers; the person is their Flow
+// id only. A problem report keeps what the person typed, with addresses and
+// phone numbers masked, and keeps their email only when they asked for a
+// response (notify=yes, tagNotify).
+export function scrubEvent(event) {
+  if (!event || typeof event !== 'object') return event;
+  const report = event.type === 'feedback';
+  if (!report) {
+    event.message = maskText(event.message);
+    if (event.logentry) event.logentry = { ...event.logentry, message: maskText(event.logentry.message), formatted: maskText(event.logentry.formatted), params: undefined };
+    for (const value of event.exception?.values ?? []) value.value = maskText(value.value);
+    if (event.extra) event.extra = Object.fromEntries(Object.entries(event.extra).map(([key, value]) => [key, maskText(typeof value === 'string' ? value : '<data>')]));
+  }
+  if (Array.isArray(event.breadcrumbs)) {
+    event.breadcrumbs = event.breadcrumbs.map(({ data, message, ...crumb }) => ({ ...crumb, ...(message ? { message: maskText(message) } : {}), ...(data?.url ? { data: { url: withoutQuery(data.url), method: data.method, status_code: data.status_code } } : {}) }));
+  }
+  if (event.request) event.request = { method: event.request.method, url: withoutQuery(event.request.url) };
+  if (event.user) event.user = event.user.id == null ? {} : { id: event.user.id };
+  const feedback = event.contexts?.feedback;
+  if (feedback) {
+    const keepContact = event.tags?.notify === 'yes';
+    event.contexts.feedback = { ...feedback, message: maskText(feedback.message, CONTACT_MASKS), name: undefined, contact_email: keepContact ? feedback.contact_email : undefined };
+    if (keepContact && feedback.contact_email) event.user = { ...event.user, email: feedback.contact_email };
+  }
+  return event;
+}
+
 /** Resolves to a function that opens the "Report a problem" form, or null. */
 export async function startMonitoring({ flow, person }) {
   const config = await flow('/api/monitoring');
@@ -142,7 +198,9 @@ export async function startMonitoring({ flow, person }) {
     showName: false,
     // The form fills in the signed-in person's name and email (setUser).
     useSentryUser: { name: 'username', email: 'email' },
-    enableScreenshot: true,
+    // A screenshot is the screen as it is, names and all: off unless the
+    // installation turns it on (SENTRY_SCREENSHOT).
+    enableScreenshot: Boolean(config.screenshot),
     triggerLabel: 'Report a problem',
     formTitle: 'Report a problem',
     messageLabel: 'What went wrong?',
@@ -180,13 +238,15 @@ export async function startMonitoring({ flow, person }) {
     // Replay: never a whole visit, only the minute before a report or error.
     replaysSessionSampleRate: 0,
     replaysOnErrorSampleRate: config.replay ? 1 : 0,
+    beforeSend: scrubEvent,
     beforeSendSpan: scrubSpan,
     initialScope: { tags: config.tags ?? {} },
   });
   // Read when the report is sent: the tick box of the form open now.
   let wantsResponse = false;
-  Sentry.getClient()?.on('beforeSendFeedback', (event) => tagNotify(event, wantsResponse));
-  // Who reported or met the error, so the lab can follow up.
+  Sentry.getClient()?.on('beforeSendFeedback', (event) => { tagNotify(event, wantsResponse); scrubEvent(event); });
+  // Fills in the report form. Events keep only the Flow id (scrubEvent); a
+  // report keeps the email only when the person asks for a response.
   Sentry.setUser({ id: person.id, email: person.email, username: person.name || undefined });
   const feedback = config.feedback ? Sentry.getFeedback() : null;
   if (!feedback) return null;

package/server/ui/price-list.js

@@ -245,8 +245,11 @@ export async function renderPriceList(main, ui) {
       type: 'button', role: 'tab', 'aria-selected': String(tab === id), onclick: () => { tab = id; draw(); },
     }, label, h('span', { class: 'fx-tabs__count' }, String(count)))));
 
+    // A list Flow could not read: its differences are not shown.
+    const unread = (data.unread ?? []).length
+      ? notice(`${data.unread.map((u) => u.name).join(' and ')} list not read, so its differences are not shown. Flow reads it again at its next sync, in a few minutes: reload this page then. If it stays, open Integrations.`, 'warn') : null;
     if (!shown.length) {
-      host.replaceChildren(h('p', { class: 'fx-empty' }, words || view.groups.length ? 'No code matches.' : tab === 'archived' ? 'No archived codes.' : 'No codes yet.'));
+      host.replaceChildren(...[unread, h('p', { class: 'fx-empty' }, words || view.groups.length ? 'No code matches.' : tab === 'archived' ? 'No archived codes.' : 'No codes yet.')].filter(Boolean));
     } else {
       const columns = view.columns.map((id) => ({ id, label: PRICE_COLUMNS[id], ...COLUMN_DEFS[id] }));
       const itemRow = (item) => h('tr', { class: 'fx-row-link', tabindex: '0', onclick: () => edit(item), onkeydown: (event) => { if (event.key === 'Enter') edit(item); } },
@@ -260,7 +263,7 @@ export async function renderPriceList(main, ui) {
         open: !folded.has(label), onFold: () => { if (folded.has(label)) folded.delete(label); else folded.add(label); draw(); },
         span: columns.length + 1,
       });
-      host.replaceChildren(heads.table({
+      host.replaceChildren(...[unread].filter(Boolean), heads.table({
         className: 'fx-table--rows fx-price__table', columns,
         rows: groups.map((g) => h('tbody', {}, g.label == null ? null : head(g), g.label != null && folded.has(g.label) ? null : g.jobs.map(itemRow))),
       }));

package/skills/flow/SKILL.md

@@ -54,6 +54,7 @@ for sends, voids and deletes get the person's yes in the chat.
 | Add a rule | `flow.sh post invoicing/rules '{"name":"...","conditions":[{"field":"job_total","test":"at_most","value":0}],"action":{"kind":"wait"}}'` |
 | Change or turn off a rule | `flow.sh put invoicing/rules/<id> '{"enabled":false}'` |
 | Delete a rule | `flow.sh delete invoicing/rules/<id>` |
+| Remakes are never billed | `flow.sh post invoicing/rules '{"name":"Remake","conditions":[{"field":"remake","test":"is","value":true}],"action":{"kind":"non_chargeable"}}'` |
 | Rule that offers an item (shipping) | `flow.sh post invoicing/rules '{"name":"Shipping","conditions":[{"field":"line_item","test":"has_not","value":"S/H"}],"action":{"kind":"pending","note":"Add shipping, or skip with a reason.","addItem":"S/H"}}'` |
 | Add the rule's item to a draft | `flow.sh post invoicing/invoices/<id>/rules/<ruleId>/add-item '{}'` |
 | Skip a rule for one job | on its draft: `flow.sh post invoicing/invoices/<id>/rules/<ruleId>/exception '{"reason":"..."}'`; no draft yet: `flow.sh post invoicing/jobs/<jobId>/rules/<ruleId>/exception '{"reason":"..."}'` |
@@ -70,6 +71,10 @@ the person's reason for a skip. An exception ends when the job's lines change
 (`current: false` in the rule's exceptions list): ask the person again. The work system must get the item too: tell
 the person which jobs show "needs <item>" on the job board.
 
+A matching `non_chargeable` rule wins over wait rules, and it releases old
+held history jobs that have no accounting invoice. Settle reconciliation work
+(remakes, own clinics) with rules, never with one-off clean-ups.
+
 Keep the rules few and clear. When you work with rules, read all of them
 (`flow.sh get invoicing/rules`) and look for rules that do the same job, that
 overlap, or that no longer match anything. Show the person a short list: which
@@ -139,8 +144,33 @@ How to read `price-list`:
 - `items`: each Flow code with its `links` (the linked Xero item or Seazona
   product, as `record`) and `findings`. A finding `kind` is `price` (Flow and
   the other system differ: `flow` and `other` in cents), `tax`, `missing` (the
-  linked record is gone) or `not_linked` (no Xero item for this code).
+  linked record is gone), `not_linked` (no Xero item for this code) or `code`
+  (the linked Xero item has another code while another Xero item has the
+  Flow code: check that the link is the right one).
 - `unlinked`: Xero items and Seazona products that no Flow code has yet.
+- `unread`: lists Flow could not read now. Their differences are not shown,
+  so say "not read", never "no differences", and read again later.
+
+How the three lists fit:
+
+- Each system keeps its own names and codes. Flow joins them by links, never
+  by renaming. Do not ask the person to rename a record only to match.
+- Many Seazona products can link to one Flow code (two names, one price).
+  One Flow code has one Xero item at most.
+- A send uses the Xero link (by Xero's id), so a Flow code can send as a
+  Xero item with another code. With no link, it sends as the same code.
+- A link to a record that another code had moves it. The answer has `moved`
+  (`price-links`) or `movedFrom` (one link): tell the person which code
+  lost it.
+- The rule field `accounting_item` ("Every item is in accounting") holds a job
+  with a line whose code does not send as a Xero item that sells. The reason
+  names the codes. A lab that must never invoice an item Xero does not have
+  keeps one such rule (Then wait, or pending with a note).
+
+Before you call a difference a new price or a new product, check the mapping:
+a wrong line mapping, a wrong link or a rule is the usual cause. Prices and
+products change seldom. Read the line's `line-labels` row, its mapping and
+the code's links first, and say which one is wrong.
 
 Reconcile steps: