@arcforgelabs/flow 2026.10.27 → 2026.10.30

package/server/core/line-mapping.js

@@ -0,0 +1,337 @@
+import { and, asc, eq, isNull, sql } from 'drizzle-orm';
+import { LINE_MAPPING_KINDS, lineMappings, pipelineCursors, priceItems } from '../db/schema.js';
+import { FlowError, notFound } from './errors.js';
+
+// Line mapping (docs/LINE_MAPPING.md): how each line a work system reports
+// finds the lab's price item before the job reaches the ledger. The routine is
+// a list of steps, tried in order; the first step that answers wins. Every
+// step reads either the lab's price list or the lab's own mapping rows, so no
+// lab's labels or codes are fixed in Flow's code.
+//
+//   same_code           the line's own code is a price item code
+//   account             an account row: a line with no price item (a surcharge)
+//   saved               a row a person saved for this label at this price
+//   catalog_name        exactly one price item has this name
+//   price_alias         a row for this label at this price
+//   catalog_name_price  the price items with this name, at this price: one wins,
+//                       more than one stops the line for a person
+//   catalog_score       the price item at this price whose name is closest
+//   alias               a row for this label, or for the start of it
+//
+// A mapped line keeps the work system's amount and tax flag; the price item
+// gives its code, its text and, when the work system gave none, its price and
+// tax. A line no step answers keeps no code, so the ledger holds the job.
+
+export const STEPS = Object.freeze([
+  'same_code', 'account', 'saved', 'catalog_name', 'price_alias', 'catalog_name_price', 'catalog_score', 'alias',
+]);
+export const STEP_LABELS = Object.freeze({
+  same_code: 'Same code',
+  account: 'Account lines',
+  saved: 'Saved choices',
+  catalog_name: 'Price list name',
+  price_alias: 'Label and price',
+  catalog_name_price: 'Price list name and price',
+  catalog_score: 'Closest name at the same price',
+  alias: 'Label',
+});
+export const ZERO_LINES = Object.freeze(['keep', 'drop']);
+export const MAPPING_DEFAULTS = Object.freeze({ steps: [...STEPS], zeroLines: 'keep' });
+
+const SCORE_MIN = 16;
+const SCORE_GAP = 8;
+const MAX_MAPPINGS = 2000;
+const invalid = (message) => new FlowError('invalid', message);
+
+// Text in the form every comparison uses: lower case, "&" as "and", every
+// other mark a space.
+export function lineText(value) {
+  return String(value ?? '').trim().toLowerCase().replace(/&/g, ' and ').replace(/[^a-z0-9]+/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+// The label without what varies between orders of the same item: sizes
+// ("2 x 3"), arch ("upper", "lower 4") and "per set" or "per unit".
+export function lineLookupText(value) {
+  return lineText(value)
+    .replace(/\b\d+\s*x\s*\d+(?:\s+\d+)?\b/g, ' ')
+    .replace(/\b(upper|lower)\s+\d+\b/g, ' ')
+    .replace(/\b(upper|lower)\b/g, ' ')
+    .replace(/\bper set\b/g, ' ')
+    .replace(/\bper unit\b/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+// A label that carries its own quantity and unit price: "Teeth (6 x $12.50)".
+export function quantityOf(text) {
+  const raw = String(text ?? '').trim();
+  const found = raw.match(/\((\d+(?:\.\d+)?)\s*x\s*\$?([0-9]+(?:\.\d{1,2})?)\)/i);
+  if (!found) return { base: raw, quantity: 1, unitAmountCents: null };
+  const quantity = Number(found[1]);
+  const base = raw.replace(found[0], ' ').replace(/\s+/g, ' ').trim();
+  return {
+    base: base || raw,
+    quantity: Number.isInteger(quantity) && quantity > 0 ? quantity : 1,
+    unitAmountCents: Number.isInteger(quantity) && quantity > 0 ? Math.round(Number(found[2]) * 100) : null,
+  };
+}
+
+const tokens = (text) => [...new Set(text.split(' ').filter((t) => t.length > 1))];
+
+// How close a price item's name is to a label. The weights are the earlier
+// lab app's, so its results carry over.
+export function nameScore(item, { exact, lookup, original }) {
+  const texts = [lineText(item.name), lineText(item.description)];
+  const lookups = [lineLookupText(item.name), lineLookupText(item.description)];
+  let score = 0;
+  if (exact && texts.includes(exact)) score += 120;
+  if (lookup && lookups.includes(lookup)) score += 90;
+  if (lookup && lookups.some((t) => t && (t.includes(lookup) || lookup.includes(t)))) score += 35;
+  const lookupTokens = new Set(lookups.flatMap(tokens));
+  for (const token of tokens(lookup)) if (lookupTokens.has(token)) score += 8;
+  const exactTokens = new Set(texts.flatMap(tokens));
+  for (const token of tokens(exact)) if (exactTokens.has(token)) score += 8;
+  if (original && texts.some((t) => t && t.includes(original))) score += 20;
+  return score;
+}
+
+// The lab's price list and mapping rows, indexed once for a run.
+export function mappingContext({ items = [], mappings = [], config = MAPPING_DEFAULTS } = {}) {
+  const live = items.filter((i) => !i.archivedAt);
+  const byCode = new Map(live.map((i) => [i.code, i]));
+  const byCodeText = new Map(live.map((i) => [lineText(i.code), i]));
+  const byText = new Map();
+  const byPrice = new Map();
+  const add = (map, key, item) => {
+    if (!key) return;
+    if (!map.has(key)) map.set(key, []);
+    if (!map.get(key).includes(item)) map.get(key).push(item);
+  };
+  for (const item of live) {
+    for (const text of [lineText(item.name), lineText(item.description), lineLookupText(item.name), lineLookupText(item.description)]) add(byText, text, item);
+    add(byPrice, item.unitAmountCents, item);
+  }
+  const rows = mappings.filter((m) => m.enabled !== false);
+  const rowsOf = (kind) => rows.filter((m) => m.kind === kind);
+  return { byCode, byCodeText, byText, byPrice, rowsOf, config: { ...MAPPING_DEFAULTS, ...config } };
+}
+
+const rowMatches = (row, lookup) => (row.match === 'starts_with' ? lookup === row.label || lookup.startsWith(`${row.label} `) : lookup === row.label);
+
+// Maps one line. Answers the line as the ledger takes it, with `mappedBy` (the
+// step) and `label` (the lookup text), or `skip: true` for a zero line the
+// routine drops. A line no step answers comes back with `unmapped` set.
+export function mapLine(line, context) {
+  const { config } = context;
+  const original = String(line.description ?? '').trim();
+  const meta = quantityOf(original);
+  const exact = lineText(meta.base);
+  const lookup = lineLookupText(meta.base);
+  const lineCents = line.unitAmountCents ?? null;
+  const price = meta.unitAmountCents ?? lineCents;
+  const quantity = meta.unitAmountCents !== null ? meta.quantity : (line.quantity ?? 1);
+  const base = { ...line, label: lookup || exact || null };
+  if (lineCents !== null && lineCents <= 0 && config.zeroLines === 'drop') return { ...base, skip: true, mappedBy: 'zero_line' };
+
+  const toItem = (item, step, taxCode = null) => ({
+    ...base,
+    itemCode: item.code,
+    accountCode: null,
+    description: (item.description || item.name || original).trim(),
+    quantity,
+    unitAmountCents: price ?? item.unitAmountCents,
+    taxCode: taxCode ?? line.taxCode ?? item.taxCode,
+    mappedBy: step,
+  });
+  const fromRow = (row, step) => {
+    const item = context.byCode.get(row.itemCode);
+    return item ? toItem(item, step, row.taxCode) : null;
+  };
+  const unmapped = (reason) => ({ ...base, itemCode: null, accountCode: null, mappedBy: null, unmapped: reason });
+
+  for (const step of config.steps) {
+    switch (step) {
+      case 'same_code': {
+        const item = line.itemCode ? context.byCode.get(line.itemCode.trim()) ?? context.byCodeText.get(lineText(line.itemCode)) : null;
+        if (item) return toItem(item, step);
+        break;
+      }
+      case 'account': {
+        const row = context.rowsOf('account').find((r) => rowMatches(r, lookup));
+        if (row) {
+          return {
+            ...base, itemCode: null, accountCode: row.accountCode, description: row.description || original, quantity,
+            unitAmountCents: price, taxCode: row.taxCode ?? line.taxCode, mappedBy: step,
+          };
+        }
+        break;
+      }
+      case 'saved':
+      case 'price_alias': {
+        if (price === null) break;
+        const row = context.rowsOf(step).find((r) => r.unitAmountCents === price && rowMatches(r, lookup));
+        const mapped = row && fromRow(row, step);
+        if (mapped) return mapped;
+        break;
+      }
+      case 'catalog_name': {
+        const found = [...new Set([...(context.byText.get(exact) ?? []), ...(context.byText.get(lookup) ?? [])])];
+        if (found.length === 1) return toItem(found[0], step);
+        break;
+      }
+      case 'catalog_name_price': {
+        if (price === null) break;
+        const found = [...new Set([...(context.byText.get(exact) ?? []), ...(context.byText.get(lookup) ?? [])])]
+          .filter((i) => i.unitAmountCents === price);
+        if (found.length === 1) return toItem(found[0], step);
+        if (found.length > 1) return unmapped(`more than one price item is named "${original}" at this price`);
+        break;
+      }
+      case 'catalog_score': {
+        if (price === null) break;
+        const scored = (context.byPrice.get(price) ?? [])
+          .map((item) => ({ item, score: nameScore(item, { exact, lookup, original: lineText(original) }) }))
+          .sort((a, b) => b.score - a.score || a.item.name.localeCompare(b.item.name) || a.item.code.localeCompare(b.item.code));
+        const [top, next] = scored;
+        if (top && top.score >= SCORE_MIN && !(next && top.score < next.score + SCORE_GAP)) return toItem(top.item, step);
+        break;
+      }
+      case 'alias': {
+        const rows = context.rowsOf('alias');
+        const row = rows.find((r) => r.match === 'exact' && rowMatches(r, lookup)) ?? rows.find((r) => r.match === 'starts_with' && rowMatches(r, lookup));
+        const mapped = row && fromRow(row, step);
+        if (mapped) return mapped;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return unmapped(original ? `no mapping step found a price item for "${original}"` : 'the line has no text');
+}
+
+// Maps every line of a job. Lines the routine drops leave the job.
+export function mapLines(lines, context) {
+  return lines.map((line) => mapLine(line, context)).filter((l) => !l.skip)
+    .map(({ skip: _skip, unmapped: _unmapped, ...line }) => line);
+}
+
+function readConfig(raw = {}) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw invalid('the routine settings must be an object');
+  const out = { ...MAPPING_DEFAULTS };
+  if ('steps' in raw) {
+    if (!Array.isArray(raw.steps) || raw.steps.some((s) => !STEPS.includes(s)) || new Set(raw.steps).size !== raw.steps.length) {
+      throw invalid(`steps must list some of ${STEPS.join(', ')}, each once`);
+    }
+    out.steps = raw.steps;
+  }
+  if ('zeroLines' in raw) {
+    if (!ZERO_LINES.includes(raw.zeroLines)) throw invalid(`zeroLines must be one of ${ZERO_LINES.join(', ')}`);
+    out.zeroLines = raw.zeroLines;
+  }
+  return out;
+}
+export { readConfig as readMappingConfig };
+
+const shape = (r) => ({
+  id: r.id, kind: r.kind, match: r.match, label: r.label, unitAmountCents: r.unitAmountCents, itemCode: r.itemCode,
+  accountCode: r.accountCode, taxCode: r.taxCode, description: r.description, enabled: r.enabled, origin: r.origin, updatedAt: r.updatedAt,
+});
+
+const shortText = (value, name, max = 200) => {
+  if (value === null || value === undefined || value === '') return null;
+  if (typeof value !== 'string' || value.trim().length > max) throw invalid(`${name} must be text of ${max} characters at most`);
+  return value.trim() || null;
+};
+
+export function readMapping(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw invalid('the mapping must be an object');
+  const known = ['kind', 'match', 'label', 'unitAmountCents', 'itemCode', 'accountCode', 'taxCode', 'description', 'enabled'];
+  const unknown = Object.keys(raw).filter((k) => !known.includes(k));
+  if (unknown.length) throw invalid(`unknown field: ${unknown[0]}`);
+  if (!LINE_MAPPING_KINDS.includes(raw.kind)) throw invalid(`kind must be one of ${LINE_MAPPING_KINDS.join(', ')}`);
+  const match = raw.match ?? 'exact';
+  if (!['exact', 'starts_with'].includes(match)) throw invalid('match must be exact or starts_with');
+  const label = lineLookupText(raw.label) || lineText(raw.label);
+  if (!label || label.length > 200) throw invalid('the label must be text of 200 characters at most');
+  const priced = ['price_alias', 'saved'].includes(raw.kind);
+  let unitAmountCents = raw.unitAmountCents ?? null;
+  if (unitAmountCents !== null && (!Number.isInteger(unitAmountCents) || unitAmountCents < 0 || unitAmountCents > 100_000_000)) {
+    throw invalid('unitAmountCents must be whole cents');
+  }
+  if (priced && unitAmountCents === null) throw invalid('this kind needs a unit price');
+  if (!priced) unitAmountCents = null;
+  const taxCode = raw.taxCode ?? null;
+  if (taxCode !== null && !['GST', 'GST_FREE'].includes(taxCode)) throw invalid('taxCode must be GST or GST_FREE');
+  const itemCode = shortText(raw.itemCode, 'itemCode', 100);
+  const accountCode = shortText(raw.accountCode, 'accountCode', 20);
+  if (raw.kind === 'account' ? !accountCode : !itemCode) throw invalid(raw.kind === 'account' ? 'an account line needs an account code' : 'the mapping needs a price item');
+  const enabled = raw.enabled ?? true;
+  if (typeof enabled !== 'boolean') throw invalid('enabled must be true or false');
+  return {
+    kind: raw.kind, match, label, unitAmountCents,
+    itemCode: raw.kind === 'account' ? null : itemCode,
+    accountCode: raw.kind === 'account' ? accountCode : null,
+    taxCode, description: shortText(raw.description, 'description'), enabled,
+  };
+}
+
+export async function listMappings(db, organisationId) {
+  const rows = await db.select().from(lineMappings).where(eq(lineMappings.organisationId, organisationId))
+    .orderBy(asc(lineMappings.kind), asc(lineMappings.label), asc(lineMappings.unitAmountCents));
+  return rows.map(shape);
+}
+
+// A change to the mappings reads every job again on the next pipeline run, so
+// jobs already in the ledger take the new mapping. It reads Flow's own copy of
+// the work system, not the work system.
+export async function remapJobs(db, organisationId) {
+  await db.delete(pipelineCursors).where(and(eq(pipelineCursors.organisationId, organisationId), sql`${pipelineCursors.name} like '%.work'`));
+}
+
+export async function createMapping(db, organisationId, raw, { personId = null, origin = 'person' } = {}) {
+  const mapping = readMapping(raw);
+  const [{ count }] = await db.select({ count: sql`count(*)::int` }).from(lineMappings).where(eq(lineMappings.organisationId, organisationId));
+  if (count >= MAX_MAPPINGS) throw invalid(`an organisation can have ${MAX_MAPPINGS} line mappings at most`);
+  const [row] = await db.insert(lineMappings).values({ organisationId, ...mapping, origin, updatedBy: personId })
+    .onConflictDoNothing().returning();
+  if (!row) throw new FlowError('conflict', 'a mapping for this label already exists');
+  await remapJobs(db, organisationId);
+  return shape(row);
+}
+
+async function loadMapping(db, organisationId, id) {
+  const [row] = await db.select().from(lineMappings).where(and(eq(lineMappings.organisationId, organisationId), eq(lineMappings.id, id)));
+  if (!row) throw notFound('mapping');
+  return row;
+}
+
+export async function updateMapping(db, organisationId, id, changes, { personId = null } = {}) {
+  const row = await loadMapping(db, organisationId, id);
+  if (!changes || typeof changes !== 'object' || Array.isArray(changes)) throw invalid('the change must be an object');
+  const mapping = readMapping({ ...shape(row), ...changes, id: undefined, origin: undefined, updatedAt: undefined });
+  try {
+    const [saved] = await db.update(lineMappings).set({ ...mapping, updatedBy: personId, updatedAt: sql`now()` })
+      .where(eq(lineMappings.id, row.id)).returning();
+    await remapJobs(db, organisationId);
+    return shape(saved);
+  } catch (error) {
+    if (error?.code === '23505' || error?.cause?.code === '23505') throw new FlowError('conflict', 'a mapping for this label already exists');
+    throw error;
+  }
+}
+
+export async function deleteMapping(db, organisationId, id) {
+  const row = await loadMapping(db, organisationId, id);
+  await db.delete(lineMappings).where(eq(lineMappings.id, row.id));
+  await remapJobs(db, organisationId);
+}
+
+// The price list and mapping rows for a pipeline run.
+export async function loadMappingContext(db, organisationId, config) {
+  const [items, mappings] = await Promise.all([
+    db.select().from(priceItems).where(and(eq(priceItems.organisationId, organisationId), isNull(priceItems.archivedAt))),
+    db.select().from(lineMappings).where(eq(lineMappings.organisationId, organisationId)),
+  ]);
+  return mappingContext({ items, mappings, config });
+}

package/server/core/pipeline.js

@@ -4,11 +4,12 @@ import {
   billingObligations, contacts, externalLinks, linkRejections, linkSuggestions, obligationEvents, organisations, pipelineCursors,
 } from '../db/schema.js';
 import { FlowError } from './errors.js';
-import { runAutomations } from './automations.js';
+import { listAutomations, runAutomations } from './automations.js';
 import { readInvoicingSettings } from './invoicing-rules.js';
 import { observeJob, recordAccountingEvidence, setHold } from './ledger.js';
+import { loadMappingContext, mapLines } from './line-mapping.js';
 import { linkRecord, priorLinkFor } from './links.js';
-import { enqueueJob, runNextJob } from './queue.js';
+import { deadHoldSince, deadSince, enqueueJob, runNextJob } from './queue.js';
 
 // The pipeline (docs/DATA_SPINE.md, issue 58). It joins what the integrations
 // copy into Flow, and never writes to another system:
@@ -134,13 +135,18 @@ export async function ingestWork(db, organisationId, { adapter, restart = false,
   let cursor = restart ? null : await readCursor(db, organisationId, name);
   const links = await activeLinks(db, organisationId, { system: adapter.id, entity: 'contact' });
   const contactOf = new Map(links.map((l) => [l.externalId, l.flowId]));
-  const result = { observed: 0, withoutCustomer: 0, skipped: 0, sentToReview: 0, more: false };
+  const result = { observed: 0, withoutCustomer: 0, skipped: 0, sentToReview: 0, unmappedLines: 0, more: false };
+  // Line mapping (line-mapping.js): each line finds its price item first.
+  const mapping = (await listAutomations(db, organisationId)).find((a) => a.key === 'map_lines');
+  const context = mapping?.enabled ? await loadMappingContext(db, organisationId, mapping.config) : null;
   for (let page = 0; page < pages; page += 1) {
     const { items, withdrawn, cursor: next, more } = await adapter.capabilities.pullWorkItems(cursor, { limit: 200 });
     for (const item of items) {
       const contactId = contactOf.get(String(item.clientId ?? '')) ?? null;
+      const job = context ? { ...item.ledgerJob, lines: mapLines(item.ledgerJob.lines ?? [], context) } : item.ledgerJob;
+      if (context) result.unmappedLines += job.lines.filter((l) => !l.itemCode && !l.accountCode).length;
       try {
-        await observeJob(db, organisationId, { ...item.ledgerJob, contactId });
+        await observeJob(db, organisationId, { ...job, contactId });
         result.observed += 1;
         if (!contactId) result.withoutCustomer += 1;
       } catch (error) {
@@ -442,6 +448,7 @@ export async function runPipelineOnce(db, integrations, { now = new Date() } = {
 // systems' copies and writes Flow's own records.
 export function createPipelineWorker({ db, integrations, log = console, timers = { setTimeout, clearTimeout }, everyMs = RUN_EVERY_MS, firstDelayMs = 15_000 }) {
   const workerId = `pipeline-${randomUUID()}`;
+  const startedAtMs = Date.now();
   let timer = null;
   let running = null;
   let stopped = true;
@@ -461,6 +468,9 @@ export function createPipelineWorker({ db, integrations, log = console, timers =
         if (!integrations.with('pullWorkItems').length && !integrations.with('findInvoices').length) return;
         const organisationId = await soleOrganisation(db);
         if (!organisationId) return;
+        // Issue #101: a run that gave up waits for a person, a restart or the
+        // next day; the timer never starts it again by itself.
+        if (await deadSince(db, organisationId, { kind: PIPELINE_KIND, dedupeKey: 'all', since: deadHoldSince(startedAtMs) })) return;
         await enqueueJob(db, organisationId, { kind: PIPELINE_KIND, dedupeKey: 'all' });
         const ran = await runNextJob(db, {
           workerId,
@@ -468,8 +478,10 @@ export function createPipelineWorker({ db, integrations, log = console, timers =
           handlers: { [PIPELINE_KIND]: () => runPipelineOnce(db, integrations) },
         });
         const line = ran ? `${ran.outcome}: ${JSON.stringify(ran.job.result ?? ran.job.lastError ?? {})}` : '';
-        // Log a run only when its outcome differs from the last one.
-        if (line && line !== last) log.info?.(`[pipeline] ${line}`);
+        // Log a run only when its outcome differs from the last one. A run
+        // that gave up is reported once to the error services.
+        if (ran?.outcome === 'dead') log.error?.('[pipeline] the pipeline run gave up after its last attempt');
+        if (line && line !== last) (ran.outcome === 'succeeded' ? log.info : log.warn)?.(`[pipeline] ${line}`);
         last = line || last;
       } catch (error) {
         log.error?.(`[pipeline] ${error?.code ?? 'error'}: ${error?.message ?? error}`);

package/server/core/queue.js

@@ -38,6 +38,28 @@ export async function enqueueJob(db, organisationId, {
   return { job: open, queued: false };
 }
 
+// Issue #101: the newest job of this kind and key that gave up after `since`,
+// or null. A worker on a timer checks this before it queues the next run, so
+// a job that always fails is not started again and again: it waits for a
+// person (the review item), a restart on a new release, or the next day.
+export async function deadSince(db, organisationId, { kind, dedupeKey = '', since }) {
+  const [row] = await db.select().from(backgroundJobs).where(and(
+    eq(backgroundJobs.organisationId, organisationId),
+    eq(backgroundJobs.kind, kind),
+    eq(backgroundJobs.dedupeKey, dedupeKey),
+    eq(backgroundJobs.state, 'dead'),
+    sql`${backgroundJobs.updatedAt} > ${since}`,
+  )).orderBy(sql`${backgroundJobs.updatedAt} desc`).limit(1);
+  return row ?? null;
+}
+
+// When a timer may queue the job again after it gave up: the later of this
+// process's start and one day ago.
+export const DEAD_HOLD_MS = 24 * 60 * 60 * 1000;
+export function deadHoldSince(startedAtMs, nowMs = Date.now()) {
+  return new Date(Math.max(startedAtMs, nowMs - DEAD_HOLD_MS));
+}
+
 async function giveUp(tx, job, error) {
   const [row] = await tx.update(backgroundJobs)
     .set({ state: 'dead', lockedBy: null, lockedUntil: null, lastError: error, updatedAt: sql`now()` })

package/server/core/sending.js

@@ -4,12 +4,13 @@ import { invoiceLines, invoices } from '../db/schema.js';
 import { FlowError } from './errors.js';
 import { issueInvoice } from './invoices.js';
 import { soleOrganisation } from './pipeline.js';
-import { enqueueJob, runNextJob } from './queue.js';
+import { deadHoldSince, deadSince, enqueueJob, runNextJob } from './queue.js';
 
 // Drafts, Problem, Ready and Send all ready (docs/INVOICE_SENDING.md).
 //
 // Flow checks every draft. It checks its own data first: the draft has lines,
-// a total above zero, and a price item on every line. When an accounting
+// a total above zero, and a price item (or, for a line such as a rush
+// charge, an account) on every line. When an accounting
 // system is connected, its own checks are added (for Xero: the customer
 // matches one Xero contact, every item is in Xero). A draft with a problem is
 // in Problem. A person marks a draft without one ready; any later change to
@@ -41,7 +42,7 @@ export function draftProblems(invoice, lines) {
   if (!lines.length) problems.push(problem('no_lines', 'The invoice has no lines.'));
   else if (invoice.totalCents <= 0) problems.push(problem('no_amount', 'The total is $0.00 or less.'));
   for (const line of lines) {
-    if (!line.priceItemId) problems.push(problem('line_no_item', `Line ${line.position} has no price item.`));
+    if (!line.priceItemId && !line.accountCode) problems.push(problem('line_no_item', `Line ${line.position} has no price item.`));
   }
   return problems;
 }
@@ -52,7 +53,7 @@ async function checkDrafts(db, organisationId, drafts, accounting) {
   const ids = drafts.map((d) => d.id);
   const problems = new Map();
   if (!ids.length) return problems;
-  const lines = await db.select({ invoiceId: invoiceLines.invoiceId, position: invoiceLines.position, priceItemId: invoiceLines.priceItemId })
+  const lines = await db.select({ invoiceId: invoiceLines.invoiceId, position: invoiceLines.position, priceItemId: invoiceLines.priceItemId, accountCode: invoiceLines.accountCode })
     .from(invoiceLines).where(inArray(invoiceLines.invoiceId, ids)).orderBy(asc(invoiceLines.position));
   const linesOf = Map.groupBy(lines, (l) => l.invoiceId);
   for (const draft of drafts) {
@@ -123,9 +124,10 @@ export async function markReady(db, organisationId, invoiceIds, { personId, acco
   return { marked: good.length, refused: [...problems].map(([invoiceId, found]) => ({ invoiceId, problems: found })) };
 }
 
-// Back to drafts: the drafts need another look before they go.
+// Back to drafts: the drafts need another look before they go. The new
+// updatedAt keeps "Ready when drafted" (automations.js) off them.
 export async function markNotReady(db, organisationId, invoiceIds) {
-  const rows = await db.update(invoices).set({ readyAt: null, readyBy: null })
+  const rows = await db.update(invoices).set({ readyAt: null, readyBy: null, updatedAt: sql`now()` })
     .where(and(eq(invoices.organisationId, organisationId), eq(invoices.status, 'draft'), inArray(invoices.id, invoiceIds)))
     .returning({ id: invoices.id });
   return { moved: rows.length };
@@ -214,6 +216,7 @@ export async function sendQueued(db, organisationId, { accounting, limit = WORKE
         const error = result.error ?? { code: `send_${result.outcome}`, message: `Sending ended as ${result.outcome}.` };
         await settle(db, organisationId, result.invoiceId, { sendState: 'failed', sendError: { code: error.code, message: error.message } });
         summary.failed += 1;
+        summary.refused = [...new Set([...(summary.refused ?? []), error.code])];
       }
     }
   }
@@ -229,6 +232,7 @@ function settle(db, organisationId, invoiceId, fields) {
 // the job queue.
 export function createSendWorker({ db, integrations, log = console, timers = { setTimeout, clearTimeout }, everyMs = WORKER_EVERY_MS }) {
   const workerId = `send-${randomUUID()}`;
+  const startedAtMs = Date.now();
   let timer = null;
   let running = null;
   let stopped = true;
@@ -251,13 +255,22 @@ export function createSendWorker({ db, integrations, log = console, timers = { s
         const [waiting] = await db.select({ id: invoices.id }).from(invoices)
           .where(and(eq(invoices.organisationId, organisationId), eq(invoices.sendState, 'queued'))).limit(1);
         if (!waiting) return;
+        // Issue #101: a send run that gave up waits for a person, a restart or
+        // the next day; the timer never starts it again by itself.
+        if (await deadSince(db, organisationId, { kind: SEND_KIND, dedupeKey: 'all', since: deadHoldSince(startedAtMs) })) return;
         await enqueueJob(db, organisationId, { kind: SEND_KIND, dedupeKey: 'all' });
         const ran = await runNextJob(db, {
           workerId,
           leaseMs: LEASE_MS,
           handlers: { [SEND_KIND]: () => sendQueued(db, organisationId, { accounting }) },
         });
-        if (ran) log.info?.(`[sending] ${ran.outcome}: ${JSON.stringify(ran.job.result ?? ran.job.lastError ?? {})}`);
+        if (!ran) return;
+        const line = `[sending] ${ran.outcome}: ${JSON.stringify(ran.job.result ?? ran.job.lastError ?? {})}`;
+        // An invoice the accounting system refused waits in Problem for a
+        // person; it is reported once, when it is refused.
+        if (ran.outcome === 'dead') log.error?.('[sending] the send run gave up after its last attempt');
+        if (ran.job.result?.failed) log.error?.('[sending] the accounting system refused an invoice');
+        (ran.outcome === 'succeeded' && !ran.job.result?.failed ? log.info : log.warn)?.(line);
       } catch (error) {
         log.error?.(`[sending] ${error?.code ?? 'error'}: ${error?.message ?? error}`);
       }

package/server/db/migrate-all.js

@@ -0,0 +1,26 @@
+import { migrateDatabase, openDatabase } from './index.js';
+import { adapters as shipped } from '../integrations/adapters.js';
+import { migrateAdapterSchema } from '../integrations/schema.js';
+
+// Brings a database up to this build: the core migrations, then the tables
+// of every adapter this build ships, whether or not it is on. On Replit the
+// workspace's database runs this before a publish (scripts/replit-deploy.sh
+// update-workspace), so it holds every table production can hold and
+// publishing never offers to drop one (docs/REPLIT.md).
+export async function migrateEverything(db, { adapters = shipped, log = () => {} } = {}) {
+  await migrateDatabase(db);
+  for (const adapter of adapters) {
+    if (!adapter.schema) continue;
+    await migrateAdapterSchema(db, adapter);
+    log(`${adapter.id} tables are up to date`);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const handle = openDatabase({ max: 1 });
+  try {
+    await migrateEverything(handle.db, { log: (line) => console.log(`[deploy] ${line}`) });
+  } finally {
+    await handle.close();
+  }
+}

package/server/db/migrations/0010_invoicing_rules.sql

@@ -1,4 +1,4 @@
-CREATE TABLE "automations" (
+CREATE TABLE IF NOT EXISTS "automations" (
 	"organisation_id" uuid NOT NULL,
 	"key" text NOT NULL,
 	"enabled" boolean NOT NULL,
@@ -8,7 +8,7 @@ CREATE TABLE "automations" (
 	CONSTRAINT "automations_pk" PRIMARY KEY("organisation_id","key")
 );
 --> statement-breakpoint
-CREATE TABLE "customer_billing_settings" (
+CREATE TABLE IF NOT EXISTS "customer_billing_settings" (
 	"organisation_id" uuid NOT NULL,
 	"contact_id" uuid NOT NULL,
 	"billable" boolean DEFAULT true NOT NULL,
@@ -23,7 +23,7 @@ CREATE TABLE "customer_billing_settings" (
 	CONSTRAINT "customer_billing_settings_terms_valid" CHECK ("customer_billing_settings"."payment_terms_days" is null or "customer_billing_settings"."payment_terms_days" between 0 and 365)
 );
 --> statement-breakpoint
-CREATE TABLE "invoicing_settings" (
+CREATE TABLE IF NOT EXISTS "invoicing_settings" (
 	"organisation_id" uuid PRIMARY KEY NOT NULL,
 	"send_mode" text DEFAULT 'accounting_draft' NOT NULL,
 	"stale_days" integer DEFAULT 90 NOT NULL,
@@ -39,13 +39,34 @@ CREATE TABLE "invoicing_settings" (
 	CONSTRAINT "invoicing_settings_rush_valid" CHECK ("invoicing_settings"."rush_percent" between 0 and 100)
 );
 --> statement-breakpoint
-ALTER TABLE "billing_obligations" ADD COLUMN "source_status" text;--> statement-breakpoint
-ALTER TABLE "billing_obligations" ADD COLUMN "ready_at" timestamp with time zone;--> statement-breakpoint
-ALTER TABLE "billing_obligations" ADD COLUMN "ready_by" text;--> statement-breakpoint
-ALTER TABLE "automations" ADD CONSTRAINT "automations_organisation_id_organisations_id_fk" FOREIGN KEY ("organisation_id") REFERENCES "public"."organisations"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "automations" ADD CONSTRAINT "automations_updated_by_people_id_fk" FOREIGN KEY ("updated_by") REFERENCES "public"."people"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "customer_billing_settings" ADD CONSTRAINT "customer_billing_settings_organisation_id_organisations_id_fk" FOREIGN KEY ("organisation_id") REFERENCES "public"."organisations"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "customer_billing_settings" ADD CONSTRAINT "customer_billing_settings_updated_by_people_id_fk" FOREIGN KEY ("updated_by") REFERENCES "public"."people"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "customer_billing_settings" ADD CONSTRAINT "customer_billing_settings_contact_same_org" FOREIGN KEY ("organisation_id","contact_id") REFERENCES "public"."contacts"("organisation_id","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "invoicing_settings" ADD CONSTRAINT "invoicing_settings_organisation_id_organisations_id_fk" FOREIGN KEY ("organisation_id") REFERENCES "public"."organisations"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "invoicing_settings" ADD CONSTRAINT "invoicing_settings_updated_by_people_id_fk" FOREIGN KEY ("updated_by") REFERENCES "public"."people"("id") ON DELETE set null ON UPDATE no action;
+ALTER TABLE "billing_obligations" ADD COLUMN IF NOT EXISTS "source_status" text;--> statement-breakpoint
+ALTER TABLE "billing_obligations" ADD COLUMN IF NOT EXISTS "ready_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "billing_obligations" ADD COLUMN IF NOT EXISTS "ready_by" text;--> statement-breakpoint
+DO $flow_guard$ BEGIN
+	ALTER TABLE "automations" ADD CONSTRAINT "automations_organisation_id_organisations_id_fk" FOREIGN KEY ("organisation_id") REFERENCES "public"."organisations"("id") ON DELETE no action ON UPDATE no action;
+EXCEPTION WHEN duplicate_object OR duplicate_table OR invalid_table_definition THEN NULL;
+END $flow_guard$;--> statement-breakpoint
+DO $flow_guard$ BEGIN
+	ALTER TABLE "automations" ADD CONSTRAINT "automations_updated_by_people_id_fk" FOREIGN KEY ("updated_by") REFERENCES "public"."people"("id") ON DELETE set null ON UPDATE no action;
+EXCEPTION WHEN duplicate_object OR duplicate_table OR invalid_table_definition THEN NULL;
+END $flow_guard$;--> statement-breakpoint
+DO $flow_guard$ BEGIN
+	ALTER TABLE "customer_billing_settings" ADD CONSTRAINT "customer_billing_settings_organisation_id_organisations_id_fk" FOREIGN KEY ("organisation_id") REFERENCES "public"."organisations"("id") ON DELETE no action ON UPDATE no action;
+EXCEPTION WHEN duplicate_object OR duplicate_table OR invalid_table_definition THEN NULL;
+END $flow_guard$;--> statement-breakpoint
+DO $flow_guard$ BEGIN
+	ALTER TABLE "customer_billing_settings" ADD CONSTRAINT "customer_billing_settings_updated_by_people_id_fk" FOREIGN KEY ("updated_by") REFERENCES "public"."people"("id") ON DELETE set null ON UPDATE no action;
+EXCEPTION WHEN duplicate_object OR duplicate_table OR invalid_table_definition THEN NULL;
+END $flow_guard$;--> statement-breakpoint
+DO $flow_guard$ BEGIN
+	ALTER TABLE "customer_billing_settings" ADD CONSTRAINT "customer_billing_settings_contact_same_org" FOREIGN KEY ("organisation_id","contact_id") REFERENCES "public"."contacts"("organisation_id","id") ON DELETE no action ON UPDATE no action;
+EXCEPTION WHEN duplicate_object OR duplicate_table OR invalid_table_definition THEN NULL;
+END $flow_guard$;--> statement-breakpoint
+DO $flow_guard$ BEGIN
+	ALTER TABLE "invoicing_settings" ADD CONSTRAINT "invoicing_settings_organisation_id_organisations_id_fk" FOREIGN KEY ("organisation_id") REFERENCES "public"."organisations"("id") ON DELETE no action ON UPDATE no action;
+EXCEPTION WHEN duplicate_object OR duplicate_table OR invalid_table_definition THEN NULL;
+END $flow_guard$;--> statement-breakpoint
+DO $flow_guard$ BEGIN
+	ALTER TABLE "invoicing_settings" ADD CONSTRAINT "invoicing_settings_updated_by_people_id_fk" FOREIGN KEY ("updated_by") REFERENCES "public"."people"("id") ON DELETE set null ON UPDATE no action;
+EXCEPTION WHEN duplicate_object OR duplicate_table OR invalid_table_definition THEN NULL;
+END $flow_guard$;

package/server/db/migrations/0011_invoice_rules.sql

@@ -1,4 +1,4 @@
-CREATE TABLE "invoice_rules" (
+CREATE TABLE IF NOT EXISTS "invoice_rules" (
 	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
 	"organisation_id" uuid NOT NULL,
 	"name" text NOT NULL,
@@ -15,7 +15,13 @@ CREATE TABLE "invoice_rules" (
 	CONSTRAINT "invoice_rules_name_valid" CHECK (length("invoice_rules"."name") between 1 and 120)
 );
 --> statement-breakpoint
-ALTER TABLE "invoicing_settings" ADD COLUMN "rules_seeded" boolean DEFAULT false NOT NULL;--> statement-breakpoint
-ALTER TABLE "invoice_rules" ADD CONSTRAINT "invoice_rules_organisation_id_organisations_id_fk" FOREIGN KEY ("organisation_id") REFERENCES "public"."organisations"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "invoice_rules" ADD CONSTRAINT "invoice_rules_updated_by_people_id_fk" FOREIGN KEY ("updated_by") REFERENCES "public"."people"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
-CREATE UNIQUE INDEX "invoice_rules_starter_key" ON "invoice_rules" USING btree ("organisation_id","starter_key");
+ALTER TABLE "invoicing_settings" ADD COLUMN IF NOT EXISTS "rules_seeded" boolean DEFAULT false NOT NULL;--> statement-breakpoint
+DO $flow_guard$ BEGIN
+	ALTER TABLE "invoice_rules" ADD CONSTRAINT "invoice_rules_organisation_id_organisations_id_fk" FOREIGN KEY ("organisation_id") REFERENCES "public"."organisations"("id") ON DELETE no action ON UPDATE no action;
+EXCEPTION WHEN duplicate_object OR duplicate_table OR invalid_table_definition THEN NULL;
+END $flow_guard$;--> statement-breakpoint
+DO $flow_guard$ BEGIN
+	ALTER TABLE "invoice_rules" ADD CONSTRAINT "invoice_rules_updated_by_people_id_fk" FOREIGN KEY ("updated_by") REFERENCES "public"."people"("id") ON DELETE set null ON UPDATE no action;
+EXCEPTION WHEN duplicate_object OR duplicate_table OR invalid_table_definition THEN NULL;
+END $flow_guard$;--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS "invoice_rules_starter_key" ON "invoice_rules" USING btree ("organisation_id","starter_key");