@arcforgelabs/flow 2026.10.37 → 2026.10.39

package/README.md

@@ -40,7 +40,7 @@ run a lab.
 | `docs/JOB_INVOICE_LINKS.md` | The pipeline: how each job links to its customer and to the accounting invoice that bills it |
 | `docs/INVOICING_RULES.md` | The invoicing rules that draft a job's invoice, and the two ways an invoice goes to Xero |
 | `docs/INVOICE_RULES.md` | Invoice rules a lab builds (When, If, Then) that make a ready job wait or never draft |
-| `docs/INVOICE_SENDING.md` | Drafts, Problem and Ready invoices, Finalise, a changed job, and Send all ready to the accounting system |
+| `docs/INVOICE_SENDING.md` | The invoice tabs (Pending, Ready, Draft, Approved, Sent, Void), a changed job, and Send all ready to the accounting system |
 | `docs/RECONCILE.md` | The daily reconcile: counts and totals per day across the work system's copy, the ledger and the accounting copy |
 | `docs/ALERTS.md` | Quiet alerts: the slim line on a page when something there needs a person, and how a person dismisses it |
 | `docs/AUTOMATIONS.md` | Automations: Flow routines that mark jobs ready to invoice and draft them, each on or off |
@@ -55,6 +55,7 @@ run a lab.
 | `docs/REPLIT.md` | A Replit workspace of this repository that follows a release channel (`FLOW_DEPLOY_REF`) |
 | `docs/INTEGRATIONS.md` | How an integration adapter is built, turned on and off, and owns its tables |
 | `docs/XERO.md` | The Xero adapter: modes, settings, rate limits, connecting Xero and draft invoices |
+| `docs/XERO_IMPORT.md` | Xero › Import: each Xero invoice in Flow's copy linked to its Flow invoice, or made into one |
 | `docs/SEAZONA.md` | The Seazona adapter: modes, settings, the rate governor, replay files and its tables |
 | `docs/SENTRY.md` | The Sentry adapter: errors and problem reports to the installation's own Sentry project |
 | `server/integrations/port.js` | The integration port every adapter implements |

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcforgelabs/flow",
-  "version": "2026.10.37",
+  "version": "2026.10.39",
   "description": "Invoicing, bill entry and a financial dashboard for labs, with Seazona and Xero integrations.",
   "license": "MIT",
   "repository": {
@@ -34,7 +34,9 @@
     "changelog:check": "node scripts/release/changelog.mjs check",
     "release:stable": "node scripts/release/release-stable.mjs",
     "theme:contrast": "node scripts/theme-contrast.mjs",
-    "db:generate": "drizzle-kit generate && node scripts/db-guard-migrations.js"
+    "db:generate": "drizzle-kit generate && node scripts/db-guard-migrations.js",
+    "db:follow-production": "node scripts/replit-workspace-db.js sync",
+    "db:follow-production:status": "node scripts/replit-workspace-db.js status"
   },
   "dependencies": {
     "@clerk/backend": "3.25.0",

package/server/api/custom-fields.js

@@ -1,7 +1,7 @@
 import express from 'express';
 import {
-  CUSTOM_FIELD_TYPES, GROUPABLE_TYPES, OPTION_COLORS, archiveField, choosablePeople, createField, jobFieldHistory, listFields,
-  listJobFieldValues, orderFields, setJobFieldValue, updateField,
+  CUSTOM_FIELD_TYPES, GROUPABLE_TYPES, OPTION_COLORS, archiveField, choosablePeople, createField, deleteField, ensureAssignee, integrationConnectedAt,
+  jobFieldHistory, listFields, listJobFieldValues, orderFields, readGroupColors, setGroupColor, setJobFieldValue, updateField,
 } from '../core/custom-fields.js';
 import { FlowError } from '../core/errors.js';
 import { resolveOrganisation } from './invoicing.js';
@@ -9,11 +9,13 @@ import { resolveOrganisation } from './invoicing.js';
 // Custom fields for jobs (server/core/custom-fields.js, docs/CUSTOM_FIELDS.md).
 //
 //   GET  /api/custom-fields[?archived=1]          the lab's fields, the work systems' own fields (read only),
-//        and the people a person field can name
-//   POST /api/custom-fields { name, type[, options] }        owner or admin: make a field
+//        the people a person field can name, and each type group's colour
+//   POST /api/custom-fields { name, type[, options, color] } owner or admin: make a field
 //   PUT  /api/custom-fields/order { ids }                   owner or admin: the field order
-//   PUT  /api/custom-fields/:id { name?, options? }         owner or admin: rename, change options
+//   PUT  /api/custom-fields/groups/:type { color }          owner or admin: a type group's colour (null: its own)
+//   PUT  /api/custom-fields/:id { name?, options?, color? } owner or admin: rename, change options or colour
 //   POST /api/custom-fields/:id/archive { archived }        owner or admin: archive or bring back
+//   DELETE /api/custom-fields/:id                           owner or admin: delete a field, its values and history
 //   GET  /api/custom-fields/values                          every job's values
 //   PUT  /api/custom-fields/values { sourceSystem, sourceJobRef, fieldId, value[, expectedUpdatedAt] }
 //        set one job's value; a stale expectedUpdatedAt gives 409 with the current value
@@ -51,15 +53,17 @@ export function createCustomFieldsRouter({ db, personAuth, work = () => [], log
 
   // The work systems' own fields: their job statuses, as the Stage lanes on
   // the Jobs board. Read from Flow's copy; a work system that fails to answer
-  // is left out, not an error.
+  // is left out, not an error. `createdAt` is when the system was connected.
   async function systemFields() {
     const fields = [];
     for (const adapter of work()) {
       try {
         const { statuses = [] } = await adapter.capabilities.listWork();
+        const seen = statuses.map((s) => s.firstSeenAt).filter(Boolean).sort()[0] ?? null;
         fields.push({
           id: `${adapter.id}:stage`, source: adapter.id, sourceLabel: adapter.name ?? adapter.id, name: 'Stage',
-          type: 'dropdown', readOnly: true, options: statuses.map((s) => ({ id: s.label, name: s.label, final: Boolean(s.final) })),
+          type: 'dropdown', readOnly: true, createdAt: await integrationConnectedAt(db, adapter.id, seen),
+          options: statuses.map((s) => ({ id: s.label, name: s.label, final: Boolean(s.final), firstSeenAt: s.firstSeenAt ?? null })),
         });
       } catch (error) {
         log.warn?.(`[custom-fields] ${adapter.id} stages: ${error.message}`);
@@ -71,8 +75,11 @@ export function createCustomFieldsRouter({ db, personAuth, work = () => [], log
   router.get('/', ...signedIn, handle(async (req, res) => {
     const organisationId = await organisationOf(req);
     const archived = req.query.archived === '1' || req.query.archived === 'true';
-    const [fields, system, chosen] = await Promise.all([listFields(db, organisationId, { archived }), systemFields(), choosablePeople(db)]);
-    res.json({ ok: true, fields, systemFields: system, people: chosen, types: CUSTOM_FIELD_TYPES, groupable: GROUPABLE_TYPES, colors: OPTION_COLORS });
+    await ensureAssignee(db, organisationId);
+    const [fields, system, chosen, groupColors] = await Promise.all([
+      listFields(db, organisationId, { archived }), systemFields(), choosablePeople(db), readGroupColors(db, organisationId),
+    ]);
+    res.json({ ok: true, fields, systemFields: system, people: chosen, types: CUSTOM_FIELD_TYPES, groupable: GROUPABLE_TYPES, colors: OPTION_COLORS, groupColors });
   }));
 
   router.post('/', ...manager, handle(async (req, res) => {
@@ -85,6 +92,11 @@ export function createCustomFieldsRouter({ db, personAuth, work = () => [], log
     res.json({ ok: true, fields });
   }));
 
+  router.put('/groups/:type', ...manager, handle(async (req, res) => {
+    const groupColors = await setGroupColor(db, await organisationOf(req), req.params.type, req.body?.color, { personId: req.person.id });
+    res.json({ ok: true, groupColors });
+  }));
+
   router.get('/values', ...signedIn, handle(async (req, res) => {
     res.json({ ok: true, values: await listJobFieldValues(db, await organisationOf(req)) });
   }));
@@ -111,5 +123,11 @@ export function createCustomFieldsRouter({ db, personAuth, work = () => [], log
     res.json({ ok: true, field });
   }));
 
+  router.delete('/:id', ...manager, handle(async (req, res) => {
+    const deleted = await deleteField(db, await organisationOf(req), req.params.id);
+    log.info?.(`[custom-fields] deleted field ${deleted.id} with ${deleted.valuesDeleted} values`);
+    res.json({ ok: true, deleted });
+  }));
+
   return router;
 }

package/server/api/invoicing.js

@@ -1,6 +1,7 @@
 import { and, asc, desc, eq, ilike, inArray, isNull, or, sql } from 'drizzle-orm';
 import express from 'express';
 import { FlowError } from '../core/errors.js';
+import { createActionGuard } from '../integrations/call-guard.js';
 import {
   createDraftInvoice, getInvoice, issueInvoice, listInvoiceVersions, reviseInvoice, updateDraftInvoice, voidInvoice,
 } from '../core/invoices.js';
@@ -17,12 +18,14 @@ import {
 } from '../core/invoicing-rules.js';
 import { boardJobs, describeObligations } from '../core/job-board.js';
 import { readBeforeAct } from '../core/read-before-act.js';
+import { invoiceMatchDetail, jobMatchDetail, listReconcile } from '../core/job-match.js';
 import { jobReference } from '../core/references.js';
 import {
-  acceptFindings, archivePriceItem, checkPrices, createPriceItem, linkPriceItem, readCatalogues, readPriceList, unlinkPriceItem, updatePriceItem,
+  acceptFindings, archivePriceItem, checkPrices, createPriceItem, linkPriceItem, linkPriceItems, MAX_LINKS_AT_ONCE, readCatalogues, readPriceList, unlinkPriceItem, updatePriceItem,
 } from '../core/price-list.js';
 import {
-  draftInvoiceForObligation, explainObligation, jobChangeFor, listObligations, setReady, useSourceLines,
+  confirmNoInvoice, draftInvoiceForObligation, explainObligation, jobChangeFor, linkJobToInvoice, listObligations,
+  setReady, settleJobChange, useSourceLines,
 } from '../core/ledger.js';
 import { isHistoryHeld } from '../core/history.js';
 import { invoicePdfDocument, pdfFields, pdfFilename, renderInvoicePdf } from '../core/invoice-pdf.js';
@@ -35,8 +38,8 @@ import {
 // UI's invoices, customers, price list and jobs pages read and write here.
 //
 //   GET   /context                    the organisations, and whether this person may issue
-//   GET   /invoices?organisationId=&status=&q=&limit=   newest first, with counts by status;
-//                                     status to_check, ready or problem lists those views (server/core/sending.js)
+//   GET   /invoices?organisationId=&status=&q=&limit=   newest first, with counts by tab;
+//                                     status is a tab: pending, ready, draft, approved, sent or void (TABS)
 //   POST  /invoices/mark-ready        { invoiceIds }: a person checked these drafts; one with a problem stays
 //   POST  /invoices/mark-not-ready    { invoiceIds }: back to To check
 //   POST  /invoices/send-ready        owner or admin: issue every ready draft and queue it for the
@@ -79,6 +82,7 @@ import {
 //   POST  /price-items/:id/links      owner or admin: { system, externalId } link a record of a system's list
 //   POST  /price-items/:id/resolve    owner or admin: Mark resolved: check again, accept what still differs
 //   DELETE /price-links/:id           owner or admin: remove a link
+//   POST  /price-links                owner or admin: { links: [{ priceItemId, system, externalId }] } many links at once
 //   GET   /automations?place=         Flow's routines, each on or off (server/core/automations.js)
 //   PUT   /automations/:key           owner or admin: { enabled, config }
 //   GET   /work-statuses              the work system's job statuses, with job counts
@@ -99,7 +103,15 @@ import {
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const DATE = /^\d{4}-\d{2}-\d{2}$/;
-const VIEWS_OF_INVOICES = ['to_check', 'ready', 'problem'];
+// The Invoices page tabs, left to right. Pending: a person must look (a
+// draft with a problem, a refused send, or out of sync with the accounting
+// system). Ready: a draft whose checks pass. Draft, Approved and Sent: an
+// issued invoice, by its stage in the accounting system (its invoiceStages;
+// Draft while it is on its way); with no accounting system, an issued invoice
+// is Approved. Void: void in Flow or in the accounting system.
+const TABS = ['pending', 'ready', 'draft', 'approved', 'sent', 'void'];
+// Earlier names a saved link may still use.
+const OLD_TABS = { problem: 'pending', to_check: 'ready', issued: 'approved' };
 const VIEWS = ['in_work', 'ready', 'pending', 'drafted', 'invoiced', 'paid', 'held', 'review_required'];
 const MAX_LINES = 200;
 const MAX_TEXT = 500;
@@ -233,7 +245,7 @@ export async function resolveOrganisation(db, raw) {
 }
 
 const jobOf = (o) => (o ? {
-  id: o.id, sourceSystem: o.sourceSystem, sourceJobRef: o.sourceJobRef, caseRef: o.caseRef, practitioner: o.practitioner, shippedOn: o.shippedOn,
+  id: o.id, sourceSystem: o.sourceSystem, sourceJobRef: o.sourceJobRef, sourceInvoiceRef: o.sourceInvoiceRef, caseRef: o.caseRef, practitioner: o.practitioner, shippedOn: o.shippedOn,
 } : null);
 
 // A job with its work system's name and its link in that system's web app
@@ -279,6 +291,46 @@ async function jobChangeDetail(db, organisationId, invoiceId, work) {
   return { ...change, contact, systemName: source?.name ?? change.sourceSystem, link: link ?? null };
 }
 
+// Each invoice's tab (TABS): Map(id -> tab), the ids on each tab, the
+// problems of each pending one and the ones on their way to the accounting
+// system. Drafts come from the draft checks (sending.js); issued invoices
+// from the accounting system's stages, read from Flow's copy (no calls).
+async function invoiceTabs(db, organisationId, system) {
+  const [views, issued, voided, stages] = await Promise.all([
+    invoiceViews(db, organisationId, { accounting: system }),
+    db.select({ id: invoices.id }).from(invoices).where(and(eq(invoices.organisationId, organisationId), eq(invoices.status, 'issued'))),
+    db.select({ id: invoices.id }).from(invoices).where(and(eq(invoices.organisationId, organisationId), eq(invoices.status, 'void'))),
+    typeof system?.capabilities?.invoiceStages === 'function' ? system.capabilities.invoiceStages({ organisationId }) : new Map(),
+  ]);
+  const tabOf = new Map();
+  for (const id of [...views.toCheck, ...views.ready]) tabOf.set(id, 'ready');
+  for (const { id } of issued) tabOf.set(id, issuedTab(id, { views, stages, system }));
+  for (const { id } of voided) tabOf.set(id, 'void');
+  for (const id of views.problems.keys()) tabOf.set(id, 'pending');
+  const ids = Object.fromEntries(TABS.map((t) => [t, []]));
+  for (const [id, tab] of tabOf) ids[tab].push(id);
+  return { tabOf, ids, problems: views.problems, sending: views.sending };
+}
+
+function issuedTab(id, { views, stages, system }) {
+  if (views.problems.has(id)) return 'pending';
+  if (!system) return 'approved';
+  if (views.sending.has(id)) return 'draft';
+  return stages.get(id) ?? 'draft';
+}
+
+// One invoice's tab, for its page (and its pager).
+async function tabOfInvoice(db, organisationId, invoice, view, accounting) {
+  if (invoice.status === 'void') return 'void';
+  if (view === 'problem') return 'pending';
+  if (invoice.status === 'draft') return 'ready';
+  if (!accounting) return 'approved';
+  if (view === 'sending') return 'draft';
+  const stages = typeof accounting.capabilities.invoiceStages === 'function'
+    ? await accounting.capabilities.invoiceStages({ organisationId, invoiceIds: [invoice.id] }) : new Map();
+  return stages.get(invoice.id) ?? 'draft';
+}
+
 async function invoiceDetail(db, organisationId, invoiceId, accounting = null, work = []) {
   const invoice = await getInvoice(db, organisationId, invoiceId);
   const [[contact], versions, jobs, jobChange] = await Promise.all([
@@ -288,10 +340,12 @@ async function invoiceDetail(db, organisationId, invoiceId, accounting = null, w
     jobsByInvoice(db, organisationId, [invoiceId]),
     jobChangeDetail(db, organisationId, invoiceId, work),
   ]);
+  const viewed = await invoiceView(db, organisationId, invoice, { accounting });
   return {
     jobChange,
     ...invoice,
-    ...(await invoiceView(db, organisationId, invoice, { accounting })),
+    ...viewed,
+    tab: await tabOfInvoice(db, organisationId, invoice, viewed.view, accounting),
     // Where a draft goes when it is sent, and how: this customer's send mode.
     sendsTo: accounting?.name ?? null,
     sendMode: accounting && invoice.status === 'draft'
@@ -305,11 +359,29 @@ async function invoiceDetail(db, organisationId, invoiceId, accounting = null, w
   };
 }
 
+// A person's Recheck reads a job from its work system at most once in this
+// time; a second click inside it answers from Flow's copy.
+const RECHECK_GAP_MS = 10 * 1000;
+
+// The buttons here that may call a connected system, and how long each waits
+// before it runs again (the action guard, server/integrations/call-guard.js).
+// A send or a draft is one at a time, and a draft waits per job, so ticking
+// many jobs still works. Check prices reads Flow's copies only, so it has no
+// wait.
+export const INVOICING_ACTIONS = Object.freeze({
+  sendReady: { cooldownMs: 0, budget: false },
+  sendAgain: { cooldownMs: 0, budget: false },
+  draftJob: { cooldownMs: 10_000, budget: false },
+});
+
 export function createInvoicingRouter({
   db, personAuth, log = console, liveCheckFor = () => null, accounting = () => null, work = () => [], priceSystems = () => [],
+  buttonCooldowns = true, actions = createActionGuard({ integration: 'invoicing', actions: INVOICING_ACTIONS, off: !buttonCooldowns }),
 }) {
   const router = express.Router();
+  const act = (name, key) => actions.route(name, { key });
   router.use(express.json({ limit: '64kb' }));
+  const rechecked = new Map();
 
   const signedIn = [personAuth.requireSession];
   const manager = [...signedIn, personAuth.requireRole('owner', 'admin')];
@@ -325,61 +397,46 @@ export function createInvoicingRouter({
 
   router.get('/invoices', ...signedIn, handle(log, async (req, res) => {
     const organisationId = await organisationOf(req);
-    const status = text(req.query.status);
-    if (status && ![...INVOICE_STATUSES, ...VIEWS_OF_INVOICES].includes(status)) {
-      throw invalid(`status must be one of ${[...INVOICE_STATUSES, ...VIEWS_OF_INVOICES].join(', ')}`);
+    const asked = text(req.query.status);
+    const status = OLD_TABS[asked] ?? asked;
+    if (status && !TABS.includes(status) && !INVOICE_STATUSES.includes(status)) {
+      throw invalid(`status must be one of ${TABS.join(', ')}`);
     }
     const q = text(req.query.q);
     const limit = limitOf(req.query.limit, 200, 500);
-    // Each tab switch runs this, so the independent reads run side by side;
-    // only the to-check, ready and problem lists wait on the draft checks.
+    // Each tab switch runs this, so the independent reads run side by side.
     const system = accounting();
-    const checking = invoiceViews(db, organisationId, { accounting: system });
-    const counting = db.select({ status: invoices.status, n: sql`count(*)::int` }).from(invoices)
-      .where(eq(invoices.organisationId, organisationId)).groupBy(invoices.status);
     const sendMode = system
       ? Promise.all([sendModeSummary(db, organisationId), system.capabilities.sendStatus({ organisationId })])
         .then(([summary, sendStatus]) => ({ ...summary, ...sendStatus }))
       : null;
-    const listing = (async () => {
-      const views = VIEWS_OF_INVOICES.includes(status) ? await checking : null;
-      const where = [eq(invoices.organisationId, organisationId)];
-      const only = (ids) => (ids.length ? inArray(invoices.id, ids) : sql`false`);
-      if (status === 'to_check') where.push(only(views.toCheck));
-      else if (status === 'ready') where.push(only(views.ready));
-      else if (status === 'problem') where.push(only([...views.problems.keys()]));
-      else if (status) where.push(eq(invoices.status, status));
-      if (q) {
-        const pattern = containing(q);
-        where.push(or(ilike(invoices.number, pattern), ilike(invoices.reference, pattern), ilike(contacts.name, pattern)));
-      }
-      const rows = await db.select({ invoice: invoices, contactName: contacts.name }).from(invoices)
-        .leftJoin(contacts, eq(contacts.id, invoices.contactId))
-        .where(and(...where))
-        .orderBy(desc(invoices.createdAt), desc(invoices.id))
-        .limit(limit);
-      return { rows, jobs: await jobsByInvoice(db, organisationId, rows.map((r) => r.invoice.id)) };
-    })();
-    const [views, counted, { rows, jobs }, mode] = await Promise.all([checking, counting, listing, sendMode]);
+    const [tabs, mode] = await Promise.all([invoiceTabs(db, organisationId, system), sendMode]);
+    const where = [eq(invoices.organisationId, organisationId)];
+    const only = (ids) => (ids.length ? inArray(invoices.id, ids) : sql`false`);
+    if (TABS.includes(status)) where.push(only(tabs.ids[status]));
+    else if (status) where.push(eq(invoices.status, status));
+    if (q) {
+      const pattern = containing(q);
+      where.push(or(ilike(invoices.number, pattern), ilike(invoices.reference, pattern), ilike(contacts.name, pattern)));
+    }
+    const rows = await db.select({ invoice: invoices, contactName: contacts.name }).from(invoices)
+      .leftJoin(contacts, eq(contacts.id, invoices.contactId))
+      .where(and(...where))
+      .orderBy(desc(invoices.createdAt), desc(invoices.id))
+      .limit(limit);
+    const jobs = await jobsByInvoice(db, organisationId, rows.map((r) => r.invoice.id));
     const systems = work();
-    const counts = Object.fromEntries(INVOICE_STATUSES.map((s) => [s, 0]));
-    for (const { status: s, n } of counted) counts[s] = n;
-    counts.to_check = views.toCheck.length;
-    counts.ready = views.ready.length;
-    counts.problem = views.problems.size;
-    const ready = new Set(views.ready);
-    const toCheck = new Set(views.toCheck);
     res.json({
       ok: true,
       invoices: rows.map(({ invoice, contactName }) => ({
         ...invoice,
         contactName,
         job: withLink(jobs.get(invoice.id) ?? null, systems),
-        view: views.problems.has(invoice.id) ? 'problem' : ready.has(invoice.id) ? 'ready' : toCheck.has(invoice.id) ? 'to_check'
-          : views.sending.has(invoice.id) ? 'sending' : null,
-        problems: views.problems.get(invoice.id) ?? [],
+        tab: tabs.tabOf.get(invoice.id) ?? null,
+        sending: tabs.sending.has(invoice.id),
+        problems: tabs.problems.get(invoice.id) ?? [],
       })),
-      counts,
+      counts: Object.fromEntries(TABS.map((t) => [t, tabs.ids[t].length])),
       sendsTo: system?.name ?? null,
       sendMode: mode,
       // The Linked column: one icon for each connected system.
@@ -409,7 +466,7 @@ export function createInvoicingRouter({
     res.json({ ok: true, ...(await markNotReady(db, organisationId, invoiceIdsOf(req.body))) });
   }));
 
-  router.post('/invoices/send-ready', ...manager, handle(log, async (req, res) => {
+  router.post('/invoices/send-ready', ...manager, act('sendReady'), handle(log, async (req, res) => {
     const organisationId = await organisationOf(req);
     const issueDate = optionalDate(req.body?.issueDate, 'issueDate') ?? today();
     const ids = req.body?.invoiceIds === undefined ? null : invoiceIdsOf(req.body);
@@ -420,7 +477,7 @@ export function createInvoicingRouter({
     res.json({ ok: true, ...result });
   }));
 
-  router.post('/invoices/send-again', ...manager, handle(log, async (req, res) => {
+  router.post('/invoices/send-again', ...manager, act('sendAgain'), handle(log, async (req, res) => {
     const organisationId = await organisationOf(req);
     const ids = req.body?.invoiceIds === undefined ? null : invoiceIdsOf(req.body);
     const result = await sendAgain(db, organisationId, { accounting: accounting(), personId: req.person.id, invoiceIds: ids });
@@ -486,7 +543,7 @@ export function createInvoicingRouter({
     // Ready and Send do.
     const { problems } = await invoiceView(db, organisationId, await getInvoice(db, organisationId, invoiceId));
     const held = problems.find((p) => p.code === 'job_review');
-    if (held) throw new FlowError('not_ready', `${held.message} Nothing was finalised.`);
+    if (held) throw new FlowError('not_ready', `${held.message} Nothing was approved.`);
     const issued = await issueInvoice(db, organisationId, invoiceId, { issuedBy: `person:${req.person.id}`, issueDate });
     log.info?.(`[invoicing] organisation ${organisationId}: person ${req.person.id} issued invoice ${issued.number} (version ${issued.issuedVersion})`);
     res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting(), work()) });
@@ -556,7 +613,7 @@ export function createInvoicingRouter({
     res.json({ ok: true, jobs, statuses, accountingName: accounting()?.name ?? null });
   }));
 
-  router.post('/jobs/:id/draft', ...manager, handle(log, async (req, res) => {
+  router.post('/jobs/:id/draft', ...manager, act('draftJob', (req) => req.params.id), handle(log, async (req, res) => {
     const obligationId = pathId(req.params.id, 'job');
     const organisationId = await organisationOf(req);
     // With no accounting system connected, Flow's own records are the check.
@@ -584,10 +641,85 @@ export function createInvoicingRouter({
   router.post('/jobs/:id/use-new-lines', ...manager, handle(log, async (req, res) => {
     const obligationId = pathId(req.params.id, 'job');
     const organisationId = await organisationOf(req);
-    const { invoice } = await useSourceLines(db, organisationId, obligationId, { actor: `person:${req.person.id}` });
+    const { invoice } = await useSourceLines(db, organisationId, obligationId, { actor: `person:${req.person.id}`, accept: req.body?.accept === true });
     res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoice.id, accounting(), work()) });
   }));
 
+  // "Recheck": a person thinks the work system's copy of this job is old or
+  // was wrong and has been fixed there. Flow reads this one job from the work
+  // system now (one call, its readWorkItem) into the ledger, as read before
+  // act does; a change hold whose job matches the draft again is over. Then
+  // the invoice page reloads, so every check runs again. Reads only.
+  router.post('/jobs/:id/recheck', ...signedIn, handle(log, async (req, res) => {
+    const obligationId = pathId(req.params.id, 'job');
+    const organisationId = await organisationOf(req);
+    const [obligation] = await db.select().from(billingObligations)
+      .where(and(eq(billingObligations.organisationId, organisationId), eq(billingObligations.id, obligationId)));
+    if (!obligation) throw new FlowError('not_found', 'job not found');
+    const source = work().find((a) => a.id === obligation.sourceSystem) ?? null;
+    if (typeof source?.capabilities?.readWorkItem !== 'function') throw new FlowError('not_ready', 'the work system cannot read one job');
+    // One read for each job in RECHECK_GAP_MS, whatever the clicks.
+    const last = rechecked.get(obligationId) ?? 0;
+    let outcome = 'fresh';
+    if (Date.now() - last >= RECHECK_GAP_MS) {
+      rechecked.set(obligationId, Date.now());
+      const actor = `person:${req.person.id}`;
+      const read = (await readBeforeAct(db, organisationId, [obligation], { work: source, actor, force: true })).get(obligationId);
+      outcome = 'read';
+      if (read.outcome === 'waiting') throw new FlowError('not_ready', `${source.name} could not be read: ${read.reason ?? 'try again soon'}`);
+      await settleJobChange(db, organisationId, obligationId, { actor });
+    }
+    const invoice = obligation.invoiceId ? await invoiceDetail(db, organisationId, obligation.invoiceId, accounting(), work()) : null;
+    res.json({ ok: true, outcome, invoice });
+  }));
+
+  // A job with no invoice whose match is unclear (ledger.js). The linking
+  // tool lists the matcher's suggestions, read from the accounting copy;
+  // "Make invoice" says there is none yet; "Link" picks one of them.
+  // The Reconcile page: Flow's jobs with no Flow invoice, Flow invoices with
+  // no job, and one of them beside its possible other side
+  // (core/job-match.js). Flow's own records only; no integration is called.
+  router.get('/reconcile', ...signedIn, handle(log, async (req, res) => {
+    const organisationId = await organisationOf(req);
+    res.json({ ok: true, ...await listReconcile(db, organisationId) });
+  }));
+
+  router.get('/jobs/:id/reconcile', ...signedIn, handle(log, async (req, res) => {
+    const obligationId = pathId(req.params.id, 'job');
+    const organisationId = await organisationOf(req);
+    const [obligation] = await db.select().from(billingObligations)
+      .where(and(eq(billingObligations.organisationId, organisationId), eq(billingObligations.id, obligationId)));
+    if (!obligation) throw new FlowError('not_found', 'job not found');
+    // The Reference Flow would give its invoice, from Flow's own copy only.
+    const { referenceTemplate: template } = await readInvoicingSettings(db, organisationId);
+    const source = work().find((a) => a.id === obligation.sourceSystem) ?? null;
+    const reference = await jobReference(db, organisationId, obligation, { template, work: source });
+    const detail = await jobMatchDetail(db, organisationId, obligationId, { reference, q: text(req.query.q) ?? '' });
+    res.json({ ok: true, ...detail, job: { ...detail.job, sourceName: source?.name ?? null } });
+  }));
+
+  router.get('/invoices/:id/reconcile', ...signedIn, handle(log, async (req, res) => {
+    const invoiceId = pathId(req.params.id, 'invoice');
+    const organisationId = await organisationOf(req);
+    res.json({ ok: true, ...await invoiceMatchDetail(db, organisationId, invoiceId, { q: text(req.query.q) ?? '' }) });
+  }));
+
+  router.post('/jobs/:id/no-invoice', ...manager, handle(log, async (req, res) => {
+    const obligationId = pathId(req.params.id, 'job');
+    const organisationId = await organisationOf(req);
+    const job = await confirmNoInvoice(db, organisationId, obligationId, { actor: `person:${req.person.id}` });
+    res.json({ ok: true, job: { id: job.id, accountingState: job.accountingState } });
+  }));
+
+  // Links a job to a Flow invoice that already exists.
+  router.post('/jobs/:id/link', ...manager, handle(log, async (req, res) => {
+    const obligationId = pathId(req.params.id, 'job');
+    const organisationId = await organisationOf(req);
+    const invoiceId = pathId(text(req.body?.invoiceId) ?? '', 'invoice');
+    const job = await linkJobToInvoice(db, organisationId, obligationId, { invoiceId, actor: `person:${req.person.id}` });
+    res.json({ ok: true, job: { id: job.id, invoiceId: job.invoiceId } });
+  }));
+
   router.post('/jobs/:id/ready', ...signedIn, handle(log, async (req, res) => {
     const obligationId = pathId(req.params.id, 'job');
     const organisationId = await organisationOf(req);
@@ -789,6 +921,21 @@ export function createInvoicingRouter({
     res.status(201).json({ ok: true, link: { id: link.id, system: link.system, externalId: link.externalId, externalCode: link.externalCode, matchedBy: link.matchedBy } });
   }));
 
+  router.post('/price-links', ...manager, handle(log, async (req, res) => {
+    const organisationId = await organisationOf(req);
+    const raw = req.body?.links;
+    if (!Array.isArray(raw) || !raw.length || raw.length > MAX_LINKS_AT_ONCE) throw invalid(`links must be a list of 1 to ${MAX_LINKS_AT_ONCE} links`);
+    const links = raw.map((l, at) => {
+      const system = text(l?.system);
+      const externalId = text(l?.externalId);
+      if (!system || !externalId) throw invalid(`links[${at}]: system and externalId are required`);
+      return { priceItemId: pathId(l?.priceItemId, 'price item'), system, externalId };
+    });
+    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 });
+  }));
+
   router.post('/price-items/:id/resolve', ...manager, handle(log, async (req, res) => {
     const itemId = pathId(req.params.id, 'price item');
     const organisationId = await organisationOf(req);

package/server/app.js

@@ -52,6 +52,9 @@ export function createApp({
   signInRateLimitPerMinute = 30,
   clerkProxyRateLimitPerMinute = 300,
   defaultFamily = DEFAULT_FAMILY,
+  // Buttons that call Xero or Seazona wait between presses (the action
+  // guard, server/integrations/call-guard.js). Off only in tests.
+  buttonCooldowns = true,
   log = console,
   tracing = null,
 } = {}) {
@@ -141,7 +144,7 @@ export function createApp({
     // The price list: every enabled integration that keeps its own (Xero
     // items, Seazona products).
     const priceSystems = () => integrations?.with('listPriceItems') ?? [];
-    app.use('/api/invoicing', createInvoicingRouter({ db: database.db, personAuth: auth.personAuth, log, liveCheckFor, accounting, work, priceSystems }));
+    app.use('/api/invoicing', createInvoicingRouter({ db: database.db, personAuth: auth.personAuth, log, liveCheckFor, accounting, work, priceSystems, buttonCooldowns }));
     // Custom fields for jobs (server/core/custom-fields.js): kept in Flow
     // only; the work systems' statuses show beside them, read only.
     app.use('/api/custom-fields', createCustomFieldsRouter({ db: database.db, personAuth: auth.personAuth, work, log }));
@@ -172,7 +175,7 @@ export function createApp({
       res.json(settings ? { ok: true, on: true, service: adapter.id, ...settings } : { ok: true, on: false });
     });
   }
-  for (const { path, handler } of integrations?.routes({ db: database?.db ?? null, personAuth: auth?.personAuth ?? null, log, messagePage: page }) ?? []) {
+  for (const { path, handler } of integrations?.routes({ db: database?.db ?? null, personAuth: auth?.personAuth ?? null, log, messagePage: page, buttonCooldowns }) ?? []) {
     app.use(path, handler);
   }
 

package/server/core/alerts.js

@@ -55,7 +55,7 @@ export function invoiceProblemsSource(db, { accounting = () => null } = {}) {
       page: 'invoices',
       tone: 'warn',
       title: `${plural(ids.length, 'invoice has', 'invoices have')} a problem.`,
-      action: { label: 'Open Problem', tab: 'problem' },
+      action: { label: 'Open Pending', tab: 'pending' },
       moneyAtRiskCents: Number(total),
       members: ids,
     }];

package/server/core/automations.js

@@ -91,7 +91,7 @@ export const AUTOMATIONS = Object.freeze([
     key: 'ready_when_drafted',
     place: 'invoicing',
     name: 'Ready when drafted',
-    hint: 'An automatic draft goes straight to Ready. A draft a person changed stays in Drafts.',
+    hint: 'A draft with no problem goes straight to Ready.',
     defaults: { enabled: true, config: {} },
     readConfig: () => ({}),
   },