@arcforgelabs/flow 2026.11.5 → 2026.11.7

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@arcforgelabs/flow",
-  "version": "2026.11.5",
+  "version": "2026.11.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@arcforgelabs/flow",
-      "version": "2026.11.5",
+      "version": "2026.11.7",
       "license": "MIT",
       "dependencies": {
         "@clerk/backend": "3.25.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcforgelabs/flow",
-  "version": "2026.11.5",
+  "version": "2026.11.7",
   "description": "Invoicing, bill entry and a financial dashboard for labs, with Seazona and Xero integrations.",
   "license": "MIT",
   "repository": {

package/server/api/invoicing.js

@@ -1182,7 +1182,7 @@ export function createInvoicingRouter({
     if (!system || !externalId) throw invalid('system and externalId are required');
     const link = await linkPriceItem(db, organisationId, itemId, { system, externalId }, { catalogues: await catalogues(organisationId), personId: req.person.id });
     log.info?.(`[invoicing] organisation ${organisationId}: person ${req.person.id} linked price item ${itemId} to ${system}`);
-    res.status(201).json({ ok: true, link: { id: link.id, system: link.system, externalId: link.externalId, externalCode: link.externalCode, matchedBy: link.matchedBy } });
+    res.status(201).json({ ok: true, link: { id: link.id, system: link.system, externalId: link.externalId, externalCode: link.externalCode, matchedBy: link.matchedBy, ...(link.movedFrom ? { movedFrom: link.movedFrom } : {}) } });
   }));
 
   router.post('/price-links', ...manager, handle(log, async (req, res) => {
@@ -1197,7 +1197,10 @@ export function createInvoicingRouter({
     });
     const made = await linkPriceItems(db, organisationId, links, { catalogues: await catalogues(organisationId), personId: req.person.id });
     log.info?.(`[invoicing] organisation ${organisationId}: person ${req.person.id} made ${made.length} price links`);
-    res.status(201).json({ ok: true, linked: made.length });
+    // A link another code had moves; `moved` names each one, so the caller
+    // can say which code lost it.
+    const moved = made.filter((l) => l.movedFrom).map((l) => ({ priceItemId: l.priceItemId, system: l.system, externalId: l.externalId, movedFrom: l.movedFrom }));
+    res.status(201).json({ ok: true, linked: made.length, ...(moved.length ? { moved } : {}) });
   }));
 
   router.post('/price-items/:id/resolve', ...manager, handle(log, async (req, res) => {

package/server/app.js

@@ -146,7 +146,7 @@ export function createApp({
   // Settings, Integrations: an owner turns integrations on and enters their
   // settings (server/integrations/setup.js).
   if (integrations && database && auth?.personAuth) {
-    app.use('/api/integrations', createSetupRouter({ db: database.db, registry: integrations, personAuth: auth.personAuth, secrets, log }));
+    app.use('/api/integrations', createSetupRouter({ db: database.db, registry: integrations, personAuth: auth.personAuth, secrets, log, buttonCooldowns }));
   }
   // Invoicing for signed-in people (server/api/invoicing.js). A job's draft
   // invoice needs a live check in the accounting system: the first enabled

package/server/core/automations.js

@@ -1,7 +1,7 @@
 import { and, asc, eq, sql } from 'drizzle-orm';
 import { automations, billingObligations, invoices } from '../db/schema.js';
 import { FlowError, notFound } from './errors.js';
-import { autoDraftJobs, readInvoicingSettings } from './invoicing-rules.js';
+import { autoDraftJobs, readInvoicingSettings, settleHistoryByRules } from './invoicing-rules.js';
 import { MAPPING_DEFAULTS, readMappingConfig, remapJobs } from './line-mapping.js';
 import { setReady } from './ledger.js';
 import { refreshReferences } from './references.js';
@@ -226,6 +226,9 @@ export async function runAutomations(db, organisationId, { accounting = null, wo
     if (automation.key === 'mark_ready_from_work_status') {
       summary[automation.key] = await markReadyFromWorkStatus(db, organisationId, automation.config);
     } else if (automation.key === 'draft_when_ready') {
+      // Old held jobs a non-chargeable rule matches join this run's drafts.
+      const settled = await settleHistoryByRules(db, organisationId, { accounting, now });
+      if (settled.released) summary.settle_history = settled;
       summary[automation.key] = await autoDraftJobs(db, organisationId, { accounting, work, now, actor: actorOf(automation.key) });
     } else if (automation.key === 'ready_when_drafted') {
       summary[automation.key] = await readyWhenDrafted(db, organisationId);

package/server/core/invoice-rules.js

@@ -67,10 +67,47 @@ export const FIELDS = Object.freeze({
     read: (j) => j.contactId,
   },
   customer_billable: { label: 'Customer is billable', kind: 'boolean', read: (j, { customer }) => customer.billable !== false },
+  // The work system marks the job a remake (Seazona's remake flag).
+  remake: { label: 'Remake', kind: 'boolean', read: (j) => j.remake === true },
   line_item: { label: 'Line item', kind: 'items', options: 'items', read: (j) => (j.lines ?? []).flatMap((l) => [norm(l.itemCode), norm(l.label)].filter(Boolean)) },
   line_share: { label: 'Line share of other lines (%)', kind: 'share', options: 'items', read: (j) => j.lines ?? [] },
+  // Each line with a price item sends as an item of the accounting system
+  // (Xero: a linked item that sells, else the item with the same code). A
+  // line booked to an account has no item, so it does not count. `items` is
+  // the Flow codes that send (accountingItemsFor). It is null when no
+  // accounting system is on or its list was never read: then the field has
+  // no value and no rule on it matches.
+  accounting_item: {
+    label: 'Every item is in accounting', kind: 'boolean', accounting: true,
+    read: (j, { items }) => (items ? !missingItems(j, items).length : null),
+    detail: (j, { items }) => (items && missingItems(j, items).length ? `not in accounting: ${missingItems(j, items).join(', ')}` : null),
+  },
 });
 
+// The codes on a job's lines that do not send as an accounting item.
+function missingItems(job, items) {
+  return [...new Set((job.lines ?? []).map((l) => l.itemCode).filter((c) => c && !items.has(c)))];
+}
+
+// The Flow codes that send as an item in the accounting system, for the rules
+// that read `accounting_item`. Null when no enabled rule reads it, or when no
+// accounting system answers (not connected, or its list was never read).
+// `jobs` are the jobs the rules will read, so one call serves a whole run.
+export async function accountingItemsFor(accounting, organisationId, rules, jobs) {
+  if (typeof accounting?.capabilities?.itemMatches !== 'function') return null;
+  if (!rules.some((r) => r.enabled && r.conditions.some((c) => FIELDS[c.field]?.accounting))) return null;
+  const codes = [...new Set(jobs.flatMap((j) => (j.lines ?? []).map((l) => l.itemCode).filter(Boolean)))];
+  const matched = await accounting.capabilities.itemMatches({ organisationId, codes });
+  return matched ? new Set(matched) : null;
+}
+
+// What a matched rule's fields say about this job, such as the codes not in
+// accounting, so the note names the line to fix.
+function detailOf(rule, job, context) {
+  const parts = [...new Set(rule.conditions.map((c) => FIELDS[c.field].detail?.(job, context)).filter(Boolean))];
+  return parts.length ? ` (${parts.join('; ')})` : '';
+}
+
 export const TESTS = Object.freeze({
   number: ['more_than', 'at_most', 'is', 'is_not', 'is_empty'],
   money: ['more_than', 'at_most', 'is', 'is_not'],
@@ -206,22 +243,34 @@ function matches(condition, job, context) {
 // The reasons the enabled rules give for one job, in rule order. An empty list
 // means no rule stops its draft. `customer` is the customer's own billing
 // settings (invoicing-rules.js).
-const waitingRules = (rules, job, { customer = {}, now = new Date() } = {}) => rules
-  .filter((rule) => rule.enabled && rule.trigger === 'job_ready' && !['pending', 'non_chargeable'].includes(rule.action.kind))
-  .filter((rule) => rule.conditions.every((c) => matches(c, job, { customer, now })));
-const waitMessage = (rule) => rule.action.kind === 'skip'
-  ? `rule "${rule.name}": not drafted by rule` : `rule "${rule.name}": waits for a person`;
+// `items`: the Flow codes that send as accounting items (accountingItemsFor).
+const contextOf = ({ customer = {}, now = new Date(), items = null } = {}) => ({ customer, now, items });
+// A non-chargeable rule that matches wins over the wait rules (a $0 remake
+// is never billed, so "No amount" must not hold it), and over the skip rules
+// below it in the list. Rules are in the lab's order.
+const waitingRules = (rules, job, context) => {
+  const live = rules.filter((rule) => rule.enabled && rule.trigger === 'job_ready');
+  const hit = (rule) => rule.conditions.every((c) => matches(c, job, context));
+  const free = live.findIndex((rule) => rule.action.kind === 'non_chargeable' && hit(rule));
+  return live
+    .filter((rule, at) => (free < 0 ? ['wait', 'skip'].includes(rule.action.kind) : rule.action.kind === 'skip' && at < free))
+    .filter(hit);
+};
+const waitMessage = (rule, job, context) => (rule.action.kind === 'skip'
+  ? `rule "${rule.name}": not drafted by rule` : `rule "${rule.name}": waits for a person`) + detailOf(rule, job, context);
 
 // Keep the text-only reason API for draft checks, including evaluation of
 // starter rules before they are saved. Selection/text have one owner here.
 export function ruleReasons(rules, job, options) {
-  return waitingRules(rules, job, options).map(waitMessage);
+  const context = contextOf(options);
+  return waitingRules(rules, job, context).map((rule) => waitMessage(rule, job, context));
 }
 
 // Pending work needs the saved rule identity, just as a Pending invoice does.
 export function ruleWait(rules, job, options) {
-  return waitingRules(rules, job, options).map((rule) => ({ code: 'rule',
-    message: waitMessage(rule), short: rule.name.slice(0, 40), rule: rule.id,
+  const context = contextOf(options);
+  return waitingRules(rules, job, context).map((rule) => ({ code: 'rule',
+    message: waitMessage(rule, job, context), short: rule.name.slice(0, 40), rule: rule.id,
     resolution: ruleResolution(rule),
   }));
 }
@@ -239,8 +288,8 @@ const ruleResolution = (rule) => {
 // A rule leaves a job alone when a person made an exception for it
 // (`job.ruleExceptions`, rule ids), or, for a rule with `addItem`, when the
 // draft already has that item (`job.draftItems`, codes): the fix was taken.
-export function rulePending(rules, job, { customer = {}, now = new Date() } = {}) {
-  const context = { customer, now };
+export function rulePending(rules, job, options) {
+  const context = contextOf(options);
   const excepted = new Set(job.ruleExceptions ?? []);
   const onDraft = new Set((job.draftItems ?? []).map(norm));
   return rules
@@ -248,7 +297,7 @@ export function rulePending(rules, job, { customer = {}, now = new Date() } = {}
     .filter((r) => !excepted.has(r.id) && !(r.action.addItem && onDraft.has(norm(r.action.addItem))))
     .filter((r) => r.conditions.every((c) => matches(c, job, context)))
     .map((r) => ({
-      code: 'rule', message: r.action.note, short: r.name.slice(0, 40), rule: r.id ?? null, fields: [...new Set(r.conditions.map((c) => c.field))],
+      code: 'rule', message: r.action.note + detailOf(r, job, context), short: r.name.slice(0, 40), rule: r.id ?? null, fields: [...new Set(r.conditions.map((c) => c.field))],
       resolution: ruleResolution(r), ...(r.action.addItem ? { addItem: r.action.addItem } : {}),
     }));
 }
@@ -257,8 +306,8 @@ export function rulePending(rules, job, { customer = {}, now = new Date() } = {}
 // A person drafted the job by hand, or the rule was made after the draft.
 // The list shows the rule's name. The note says to void the draft or change
 // the rule. A wait rule does not hold a draft: a person may still send one.
-export function ruleSkip(rules, job, { customer = {}, now = new Date() } = {}) {
-  const context = { customer, now };
+export function ruleSkip(rules, job, options) {
+  const context = contextOf(options);
   return rules
     .filter((r) => r.enabled && r.trigger === 'job_ready' && r.action.kind === 'skip')
     .filter((r) => r.conditions.every((c) => matches(c, job, context)))
@@ -275,8 +324,8 @@ export function ruleSkip(rules, job, { customer = {}, now = new Date() } = {}) {
 // The enabled non-chargeable rules that match one draft's job (sending.js):
 // the draft is on the Non-chargeable tab, never on Pending or Ready, and
 // Send never sends it.
-export function ruleNonChargeable(rules, job, { customer = {}, now = new Date() } = {}) {
-  const context = { customer, now };
+export function ruleNonChargeable(rules, job, options) {
+  const context = contextOf(options);
   return rules
     .filter((r) => r.enabled && r.trigger === 'job_ready' && r.action.kind === 'non_chargeable')
     .filter((r) => r.conditions.every((c) => matches(c, job, context)))

package/server/core/invoicing-rules.js

@@ -3,8 +3,9 @@ import {
   billingObligations, contacts, customerBillingSettings, externalLinks, invoicingSettings, SEND_MODES,
 } from '../db/schema.js';
 import { FlowError, notFound } from './errors.js';
-import { listRules, ruleReasons } from './invoice-rules.js';
-import { draftInvoiceForObligation } from './ledger.js';
+import { HISTORY_HOLD_REASON } from './history.js';
+import { accountingItemsFor, listRules, ruleNonChargeable, ruleReasons } from './invoice-rules.js';
+import { draftInvoiceForObligation, setHold, setReady } from './ledger.js';
 import { needsRead, readAccountingFirst, readBeforeAct, READS_PER_PASS } from './read-before-act.js';
 import { checkReferenceTemplate, DEFAULT_REFERENCE, jobReference } from './references.js';
 
@@ -197,10 +198,48 @@ export async function sendModeSummary(db, organisationId) {
 // read: Flow's own ready stage, then the lab's invoice rules (invoice-rules.js)
 // in their order. An empty list means the job may be drafted. `rules` is the
 // organisation's rules, read once per run with listRules.
-export function ruleBlockers(obligation, effective, { now = new Date(), rules = [] } = {}) {
+export function ruleBlockers(obligation, effective, { now = new Date(), rules = [], items = null } = {}) {
   const reasons = [];
   if (!obligation.readyAt) reasons.push('the job is not marked ready to invoice');
-  return [...reasons, ...ruleReasons(rules, obligation, { customer: effective, now })];
+  return [...reasons, ...ruleReasons(rules, obligation, { customer: effective, now, items })];
+}
+
+// Old jobs from the history import wait on hold, out of the rules' sight. A
+// job that a non-chargeable rule matches (own clinics, remakes) needs no
+// person: it is never billed. When no accounting invoice was found for it,
+// the rule releases it and marks it ready, and the next draft run puts its
+// draft on the Non-chargeable tab, never sent. A job with an accounting
+// invoice, or one that is unclear, stays for a person. Answers counts.
+export async function settleHistoryByRules(db, organisationId, { accounting = null, now = new Date(), limit = DRAFT_BATCH } = {}) {
+  const result = { checked: 0, released: 0 };
+  const rules = (await listRules(db, organisationId)).filter((r) => r.enabled && r.trigger === 'job_ready' && r.action.kind === 'non_chargeable');
+  if (!rules.length) return result;
+  const jobs = await db.select().from(billingObligations).where(and(
+    eq(billingObligations.organisationId, organisationId),
+    eq(billingObligations.holdState, 'held'),
+    eq(billingObligations.holdReason, HISTORY_HOLD_REASON),
+    isNull(billingObligations.invoiceId),
+    sql`${billingObligations.contactId} is not null`,
+    accounting
+      ? eq(billingObligations.accountingState, 'not_found')
+      : inArray(billingObligations.accountingState, ['not_found', 'unknown']),
+  )).orderBy(sql`${billingObligations.jobDate} desc nulls last`, billingObligations.id).limit(limit);
+  if (!jobs.length) return result;
+  const settings = await readInvoicingSettings(db, organisationId);
+  const contactIds = [...new Set(jobs.map((j) => j.contactId))];
+  const customers = await customerBillingByContact(db, organisationId, contactIds);
+  const names = await customerNames(db, organisationId, contactIds);
+  for (const job of jobs) {
+    result.checked += 1;
+    const customer = { ...effectiveSettings(settings, customers.get(job.contactId)), name: names.get(job.contactId) ?? null };
+    const [rule] = ruleNonChargeable(rules, job, { customer, now });
+    if (!rule) continue;
+    const actor = `rule:${rule.rule}`;
+    await setHold(db, organisationId, job.id, { holdState: 'none', reason: `${rule.short}: non-chargeable`, actor });
+    await setReady(db, organisationId, job.id, { actor });
+    result.released += 1;
+  }
+  return result;
 }
 
 function addDays(date, days) {
@@ -297,6 +336,8 @@ export async function autoDraftJobs(db, organisationId, { accounting = null, wor
   const liveCheck = accounting ? copyCheck(accounting, organisationId, { db }) : null;
   const invoiceDate = isoDay(now);
   let accountingRead = null;
+  // The codes that send as accounting items, for a rule that reads them.
+  const items = await accountingItemsFor(accounting, organisationId, rules, candidates);
 
   for (const candidate of candidates) {
     let effective = named(candidate.contactId);
@@ -304,7 +345,7 @@ export async function autoDraftJobs(db, organisationId, { accounting = null, wor
       result.off += 1;
       continue;
     }
-    if (ruleBlockers(candidate, effective, { now, rules }).length) {
+    if (ruleBlockers(candidate, effective, { now, rules, items }).length) {
       result.waiting += 1;
       continue;
     }
@@ -345,7 +386,10 @@ export async function autoDraftJobs(db, organisationId, { accounting = null, wor
         for (const [id, name] of extra) names.set(id, name);
       }
       effective = named(obligation.contactId);
-      if (!effective.autoDraft || ruleBlockers(obligation, effective, { now, rules }).length) {
+      // The job read again may have new codes: read their accounting items too.
+      const itemsNow = items && (obligation.lines ?? []).some((l) => l.itemCode && !items.has(l.itemCode))
+        ? await accountingItemsFor(accounting, organisationId, rules, [obligation]) : items;
+      if (!effective.autoDraft || ruleBlockers(obligation, effective, { now, rules, items: itemsNow }).length) {
         result.waiting += 1;
         continue;
       }

package/server/core/job-board.js

@@ -1,6 +1,6 @@
 import { and, eq, inArray, isNull } from 'drizzle-orm';
 import { contacts, invoices, priceItems, reviewItems } from '../db/schema.js';
-import { listRules, ruleExceptionsFor, rulePending, ruleWait } from './invoice-rules.js';
+import { accountingItemsFor, listRules, ruleExceptionsFor, rulePending, ruleWait } from './invoice-rules.js';
 import { customerBillingByContact, effectiveSettings, readInvoicingSettings, ruleBlockers } from './invoicing-rules.js';
 import { REVIEW_CHANGED, listObligations } from './ledger.js';
 import { isHistoryHeld } from './history.js';
@@ -47,6 +47,7 @@ export async function describeObligations(db, organisationId, listed, { accounti
   const settings = await readInvoicingSettings(db, organisationId);
   const customers = await customerBillingByContact(db, organisationId, contactIds);
   const rules = await listRules(db, organisationId);
+  const items = await accountingItemsFor(accounting, organisationId, rules, listed.filter((e) => !e.obligation.invoiceId).map((e) => e.obligation));
   // A rule with an item to add also checks the job as the work system has it,
   // from the first read: the lab prints from the work system, so it must be
   // right there, not only on Flow's invoice. The card says what to add.
@@ -71,7 +72,7 @@ export async function describeObligations(db, organisationId, listed, { accounti
   const waiting = (o, v) => {
     if (o.invoiceId || !['in_work', 'ready', 'pending', 'held'].includes(v)) return { waitingFor: [], waitingRules: [] };
     const customer = { ...effectiveSettings(settings, customers.get(o.contactId)), name: nameOf.get(o.contactId) ?? null };
-    const waitingRules = ruleWait(rules, o, { customer });
+    const waitingRules = ruleWait(rules, o, { customer, items });
     // Keep the existing text projection for API consumers; links use identity.
     return { waitingRules, waitingFor: [
       ...ruleBlockers(o, customer),

package/server/core/ledger.js

@@ -197,6 +197,8 @@ export async function observeJob(db, organisationId, job) {
       practitioner: job.practitioner ?? null,
       jobDate: job.jobDate ?? null,
       sourceStatus: job.sourceStatus ?? null,
+      // Seazona's remake flag, for the invoice rule field `remake`.
+      remake: job.remake === true,
       lines,
       lineFingerprint: fingerprint(lines),
       sourceTotals,
@@ -237,7 +239,7 @@ export async function observeJob(db, organisationId, job) {
         : String(existing[key] ?? '') !== String(facts[key] ?? ''));
     if (!changed.length) {
       const row = await update(tx, existing, {
-        sourceSeenAt: seenAt, mappingComplete: facts.mappingComplete, lines, jobDate: facts.jobDate, sourceStatus: facts.sourceStatus,
+        sourceSeenAt: seenAt, mappingComplete: facts.mappingComplete, lines, jobDate: facts.jobDate, sourceStatus: facts.sourceStatus, remake: facts.remake,
       });
       await statusChanged(tx, organisationId, existing, row, actor);
       return recordSourceReview(tx, row, actor);
@@ -907,10 +909,16 @@ export async function linkJobToInvoice(db, organisationId, obligationId, { invoi
     if (!invoice) throw notFound('invoice');
     if (invoice.status === 'void') throw new FlowError('invalid', 'the invoice is void');
     const rejected = await rejectSuggestions(tx, obligation, { actor });
+    // A job that waited for a person (no invoice found, or more than one fit)
+    // is settled now: the matcher reads it again on its next pass and records
+    // the invoice's stage. A link made from an accounting invoice
+    // (`accountingRef`) is exact, so the matcher follows that invoice.
+    const settled = ['not_found', 'ambiguous'].includes(obligation.accountingState);
     const row = await update(tx, obligation, {
       invoiceId: invoice.id,
       draftBasis: basisOf(obligation),
-      ...(obligation.accountingState === 'ambiguous' ? { accountingState: 'unknown' } : {}),
+      ...(settled ? { accountingState: 'unknown', accountingCheckedAt: null } : {}),
+      ...(accountingRef && !obligation.accountingRef ? { accountingRef } : {}),
       ...(obligation.readyAt ? {} : { readyAt: sql`now()`, readyBy: actor }),
     });
     await addEvent(tx, row, 'invoice_linked', actor, { invoiceId: invoice.id, matchedBy: 'person', rejected });

package/server/core/pipeline.js

@@ -426,13 +426,16 @@ export async function matchJob(db, organisationId, obligation, {
 
 async function holdIfStale(db, organisationId, obligation, { now, staleDays }) {
   if (!staleDays || !obligation.jobDate || obligation.holdState !== 'none') return false;
+  // A job with a Flow invoice, or one a rule released from the history hold
+  // (a non-chargeable job), is decided already.
+  if (obligation.invoiceId) return false;
   if (now - day(obligation.jobDate) <= staleDays * 86_400_000) return false;
   // Once only: a person who releases the job has decided.
   const [held] = await db.select({ id: obligationEvents.id }).from(obligationEvents).where(and(
     eq(obligationEvents.organisationId, organisationId),
     eq(obligationEvents.obligationId, obligation.id),
-    eq(obligationEvents.actor, ACTOR),
-    eq(obligationEvents.kind, 'held'),
+    sql`((${obligationEvents.actor} = ${ACTOR} and ${obligationEvents.kind} = 'held')
+      or (${obligationEvents.kind} = 'released' and ${obligationEvents.actor} like 'rule:%'))`,
   )).limit(1);
   if (held) return false;
   await setHold(db, organisationId, obligation.id, {

package/server/core/price-list.js

@@ -119,14 +119,20 @@ export async function archivePriceItem(db, organisationId, id, { archived = true
 }
 
 // Each connected system's list, by system id: { id, name, kind, syncedAt,
-// items, byId }. A system that cannot answer is left out (it is off, or its
-// copy is not there yet).
+// items, byId }. A system that cannot answer (its copy is not there yet, or
+// the read failed) is `unread`: { id, name, unread: true }, with no items.
+// The check then leaves its findings and alerts as they were, and the list
+// says it was not read, so "no difference" never stands for "not read".
 export async function readCatalogues(organisationId, systems = [], { log = console } = {}) {
   const out = new Map();
+  const unread = (adapter) => out.set(adapter.id, { id: adapter.id, name: adapter.name, unread: true, items: [], byId: new Map() });
   for (const adapter of systems) {
     try {
       const answer = await adapter.capabilities.listPriceItems({ organisationId });
-      if (!answer || !Array.isArray(answer.items)) continue;
+      if (!answer || !Array.isArray(answer.items)) {
+        unread(adapter);
+        continue;
+      }
       const items = answer.items.filter((i) => i && i.id);
       out.set(adapter.id, {
         id: adapter.id,
@@ -138,10 +144,12 @@ export async function readCatalogues(organisationId, systems = [], { log = conso
       });
     } catch (error) {
       log.warn?.(`[price-list] ${adapter.id} price list could not be read: ${error.message}`);
+      unread(adapter);
     }
   }
   return out;
 }
+const readOnes = (catalogues) => [...catalogues.values()].filter((c) => !c.unread);
 
 async function readLinks(db, organisationId) {
   return db.select().from(priceItemLinks).where(eq(priceItemLinks.organisationId, organisationId))
@@ -177,13 +185,17 @@ export async function linkByCode(db, organisationId, catalogue, { items = null,
 async function writeLink(db, organisationId, priceItemId, { system, externalId }, { catalogues, personId }) {
   const item = await loadItem(db, organisationId, priceItemId);
   const catalogue = catalogues.get(system);
-  if (!catalogue) throw new FlowError('conflict', `${system} is not connected, or its price list has not been read yet`);
+  if (!catalogue || catalogue.unread) throw new FlowError('conflict', `${system} is not connected, or its price list has not been read yet`);
   const record = catalogue.byId.get(String(externalId ?? ''));
   if (!record) throw notFound(`${catalogue.name} record`);
   return db.transaction(async (tx) => {
-    await tx.delete(priceItemLinks).where(and(
+    // The record's earlier link, if any. A link taken from another Flow item
+    // is named in the answer (`movedFrom`), so the caller can say which item
+    // lost it: that item no longer sends as this record.
+    const earlier = await tx.delete(priceItemLinks).where(and(
       eq(priceItemLinks.organisationId, organisationId), eq(priceItemLinks.system, system), eq(priceItemLinks.externalId, String(record.id)),
-    ));
+    )).returning({ priceItemId: priceItemLinks.priceItemId });
+    const movedFrom = earlier.find((l) => l.priceItemId !== item.id)?.priceItemId ?? null;
     if (catalogue.kind === 'accounting') {
       await tx.delete(priceItemLinks).where(and(
         eq(priceItemLinks.organisationId, organisationId), eq(priceItemLinks.system, system), eq(priceItemLinks.priceItemId, item.id),
@@ -192,7 +204,7 @@ async function writeLink(db, organisationId, priceItemId, { system, externalId }
     const [row] = await tx.insert(priceItemLinks).values({
       organisationId, priceItemId: item.id, system, externalId: String(record.id), externalCode: record.code ?? null, matchedBy: 'person', createdBy: personId,
     }).returning();
-    return row;
+    return movedFrom ? { ...row, movedFrom } : row;
   });
 }
 
@@ -234,7 +246,7 @@ export async function unlinkPriceItem(db, organisationId, linkId) {
 // caller passes the item, its links and the catalogues.
 export function findingsFor(item, links, catalogues) {
   const findings = [];
-  for (const catalogue of catalogues.values()) {
+  for (const catalogue of readOnes(catalogues)) {
     const mine = links.filter((l) => l.system === catalogue.id);
     if (!mine.length && catalogue.kind === 'accounting') {
       findings.push({ system: catalogue.id, kind: 'not_linked', code: item.code });
@@ -253,6 +265,13 @@ export function findingsFor(item, links, catalogues) {
       if (record.taxCode && record.taxCode !== item.taxCode) {
         findings.push({ ...base, kind: 'tax', flow: item.taxCode, other: record.taxCode });
       }
+      // Invoices send the linked accounting item. When another item there has
+      // the Flow code, the link decides which one (and its sales account): a
+      // person should confirm the link is the right one.
+      if (catalogue.kind === 'accounting' && record.code !== item.code
+        && catalogue.items.some((other) => other.code === item.code && String(other.id) !== String(link.externalId))) {
+        findings.push({ ...base, kind: 'code', flow: item.code, other: record.code });
+      }
     }
   }
   return findings;
@@ -285,12 +304,20 @@ async function lastClosedSignatures(db, organisationId, ids) {
 export async function checkPrices(db, organisationId, { catalogues, only = null, actor = 'flow:price-check' }) {
   const items = await db.select().from(priceItems).where(eq(priceItems.organisationId, organisationId));
   let linked = 0;
-  for (const catalogue of catalogues.values()) linked += await linkByCode(db, organisationId, catalogue, { items });
+  for (const catalogue of readOnes(catalogues)) linked += await linkByCode(db, organisationId, catalogue, { items });
   const links = await readLinks(db, organisationId);
   const live = items.filter((i) => !i.archivedAt && (!only || i.id === only));
   const latest = await lastClosedSignatures(db, organisationId, live.map((i) => i.id));
-  const summary = { linked, checked: live.length, differing: 0, opened: 0, closed: 0, accepted: 0 };
+  const unread = new Set([...catalogues.values()].filter((c) => c.unread).map((c) => c.id));
+  const summary = { linked, checked: live.length, differing: 0, opened: 0, closed: 0, accepted: 0, ...(unread.size ? { unread: [...unread], kept: 0 } : {}) };
   for (const item of live) {
+    // A list not read says nothing: an item linked to it, or whose open alert
+    // names it, keeps its alert as it was until the list is read.
+    if (unread.size && (links.some((l) => l.priceItemId === item.id && unread.has(l.system))
+      || (latest.get(item.id)?.state === 'open' && latest.get(item.id).evidence?.findings?.some((f) => unread.has(f.system))))) {
+      summary.kept += 1;
+      continue;
+    }
     const findings = findingsFor(item, links.filter((l) => l.priceItemId === item.id), catalogues);
     const signature = findingsSignature(item, findings);
     const last = latest.get(item.id);
@@ -352,7 +379,9 @@ export async function readPriceList(db, organisationId, { catalogues }) {
   }
   const linked = new Set(links.map((l) => `${l.system}:${l.externalId}`));
   return {
-    systems: [...catalogues.values()].map((c) => ({ id: c.id, name: c.name, kind: c.kind, syncedAt: c.syncedAt, count: c.items.length })),
+    systems: readOnes(catalogues).map((c) => ({ id: c.id, name: c.name, kind: c.kind, syncedAt: c.syncedAt, count: c.items.length })),
+    // Systems whose list Flow could not read now: their differences are not shown.
+    unread: [...catalogues.values()].filter((c) => c.unread).map((c) => ({ id: c.id, name: c.name })),
     items: items.map((item) => {
       const mine = linksOf.get(item.id) ?? [];
       return {
@@ -365,7 +394,7 @@ export async function readPriceList(db, organisationId, { catalogues }) {
         }),
       };
     }),
-    unlinked: [...catalogues.values()].map((c) => ({
+    unlinked: readOnes(catalogues).map((c) => ({
       system: c.id,
       records: c.items.filter((r) => r.sold !== false && !linked.has(`${c.id}:${r.id}`)),
     })),

package/server/core/sending.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { and, asc, desc, eq, inArray, sql } from 'drizzle-orm';
 import { billingObligations, contacts, invoiceLines, invoices, people, priceItems } from '../db/schema.js';
 import { FlowError } from './errors.js';
-import { listRules, ruleExceptionsFor, ruleNonChargeable, rulePending, ruleSkip } from './invoice-rules.js';
+import { accountingItemsFor, listRules, ruleExceptionsFor, ruleNonChargeable, rulePending, ruleSkip } from './invoice-rules.js';
 import { customerBillingByContact, effectiveSettings, readInvoicingSettings } from './invoicing-rules.js';
 import { issueInvoice } from './invoices.js';
 import { CHANGED_REASON, diffJobLines, sourceBillingProblems, STATUS_BACK_REASON } from './ledger.js';
@@ -118,6 +118,7 @@ async function checkDrafts(db, organisationId, drafts, accounting) {
       .innerJoin(priceItems, eq(priceItems.id, invoiceLines.priceItemId))
       .where(and(inArray(invoiceLines.invoiceId, jobs.map((j) => j.obligation.invoiceId)), sql`${invoiceLines.unitAmountCents} * ${invoiceLines.quantity} > 0`));
     const itemsOf = Map.groupBy(itemRows, (r) => r.invoiceId);
+    const items = await accountingItemsFor(accounting, organisationId, rules, jobs.map((j) => j.obligation));
     for (const { obligation, reference, customerName } of jobs) {
       const customer = { ...effectiveSettings(settings, customers.get(obligation.contactId)), name: customerName ?? null };
       const job = {
@@ -125,7 +126,7 @@ async function checkDrafts(db, organisationId, drafts, accounting) {
         ruleExceptions: exceptions.get(obligation.id) ?? [],
         draftItems: (itemsOf.get(obligation.invoiceId) ?? []).map((r) => r.code),
       };
-      const found = [...ruleNonChargeable(rules, job, { customer }), ...rulePending(rules, job, { customer }), ...ruleSkip(rules, job, { customer })];
+      const found = [...ruleNonChargeable(rules, job, { customer, items }), ...rulePending(rules, job, { customer, items }), ...ruleSkip(rules, job, { customer, items })];
       if (found.length) problems.set(obligation.invoiceId, [...(problems.get(obligation.invoiceId) ?? []), ...found]);
     }
   }

package/server/core/sync-now.js

@@ -0,0 +1,38 @@
+// Sync now (docs/INTEGRATIONS.md, "Sync now"): a person asks Flow to read its
+// systems again now, not at the next background run. An integration takes
+// part while its own "Include in Sync now" setting is on, the default. Each
+// integration's page also has its own Sync, which reads that one integration
+// whatever the setting says. Each read goes through the integration's call guard
+// and rate limit, as a background read does. The pipeline joins what they
+// bring into jobs at its next run (every 2 minutes).
+
+const named = (adapter, answer) => ({ id: adapter.id, name: adapter.name, ...answer });
+
+// What the Sync now button shows: each integration that can take part,
+// whether it does, whether a read is going, and when the last one started.
+// Reads Flow's data only.
+export async function syncNowStatus(registry) {
+  return Promise.all(registry.with('syncNowStatus').map(async (adapter) => {
+    try {
+      return named(adapter, await adapter.capabilities.syncNowStatus());
+    } catch {
+      return named(adapter, { included: false, running: false, lastAt: null, ok: null });
+    }
+  }));
+}
+
+// Starts each included integration's read, one after the other, or only the
+// integration `only` names. An integration that cannot read answers
+// `unavailable` with its reason; the others still run.
+export async function startSyncNow(registry, { only = null, actor = null, log = console } = {}) {
+  const results = [];
+  for (const adapter of registry.with('syncNow').filter((a) => !only || a.id === only)) {
+    try {
+      results.push(named(adapter, await adapter.capabilities.syncNow({ asked: Boolean(only) })));
+    } catch (error) {
+      results.push(named(adapter, { state: 'unavailable', reason: error?.message || 'the read failed' }));
+    }
+  }
+  log.info?.(`[sync-now] person ${actor ?? 'unknown'}: ${results.map((r) => `${r.id} ${r.state}`).join(', ') || 'no integration can sync'}`);
+  return results;
+}

package/server/db/migrations/0029_job_remake.sql

@@ -0,0 +1 @@
+ALTER TABLE "billing_obligations" ADD COLUMN IF NOT EXISTS "remake" boolean DEFAULT false NOT NULL;