@arcforgelabs/flow 2026.10.46 → 2026.10.47

package/VISION.md

@@ -54,16 +54,16 @@ column per stage, a card per job), with a list view of the same jobs. It
 shows every job from the case system and from Flow, with its practice, due
 date and department. Lab staff and the manager work from it.
 
-Two parts follow the board (#48):
-
-- **An intake reader.** A photo, a form or a note becomes a proposed job
-  action: update a job, create one, or add a note. A handwriting reader and a
-  low-cost decision model propose it; a person confirms it. Nothing changes
-  until a person accepts. The model steps are optional and cost money per
-  page, so the manager sees the month's cost.
-- **A practice portal.** Practice staff sign in to follow their own jobs,
-  on desktop first, with a simpler view on phones. The server limits each
-  person to their practice.
+Two parts follow the board:
+
+- **An intake reader** (#267). A photo, a form or a note becomes a proposed
+  job action: update a job, create one, or add a note. A handwriting reader
+  and a low-cost decision model propose it; a person confirms it. Nothing
+  changes until a person accepts. The model steps are optional and cost money
+  per page, so the manager sees the month's cost.
+- **A practice portal** (#268). Practice staff sign in to follow their own
+  jobs, on desktop first, with a simpler view on phones. The server limits
+  each person to their practice.
 
 Job management is a bundled module, built the same way as the integrations,
 and a lab can remove it. Where the case system cannot take a change through

package/npm-shrinkwrap.json

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

package/package.json

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

package/server/api/invoicing.js

@@ -1,10 +1,12 @@
 import { and, asc, desc, eq, ilike, inArray, isNull, or, sql } from 'drizzle-orm';
 import express from 'express';
-import { invoicePage, INVOICE_SORTS, normaliseInvoicesView } from '../ui/list-views.js';
+import { invoiceKindOf, invoicePage, INVOICE_SORTS, normaliseInvoicesView } from '../ui/list-views.js';
+import { fieldIdOf, filterRows } from '../ui/job-view.js';
+import { listFields, listJobFieldValues } from '../core/custom-fields.js';
 import { FlowError } from '../core/errors.js';
 import { createActionGuard } from '../integrations/call-guard.js';
 import {
-  createDraftInvoice, getInvoice, issueInvoice, listInvoiceVersions, reviseInvoice, updateDraftInvoice, voidInvoice,
+  createDraftInvoice, deleteDraft, getInvoice, issueInvoice, listInvoiceVersions, reviseInvoice, updateDraftInvoice, voidInvoice,
 } from '../core/invoices.js';
 import { listAutomations, saveAutomation, workStatuses } from '../core/automations.js';
 import {
@@ -45,7 +47,9 @@ import {
 //   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
 //                                     accounting system { issueDate, invoiceIds? (only these; one that fails
-//                                     a check now stays on Pending and counts as held) }
+//                                     a check now stays on Pending and counts as held; one id is all or
+//                                     nothing when its job cannot be confirmed, more than one id sends the
+//                                     rest and counts the unconfirmed in waiting) }
 //   POST  /invoices/send-again        owner or admin: queue failed sends again { invoiceIds? }
 //   GET   /invoices/:id               one invoice: lines, contact, job, issued versions, and where it sends
 //   GET   /invoices/:id/pdf?version=  the invoice as a PDF, drawn by Flow (server/core/invoice-pdf.js),
@@ -56,6 +60,8 @@ import {
 //   POST  /invoices/:id/issue         owner or admin: number it and keep the document as sent
 //   POST  /invoices/:id/revise        owner or admin: an issued invoice back to a draft
 //   POST  /invoices/:id/void          owner or admin
+//   DELETE /invoices/:id              owner or admin: a draft that was never issued.
+//                                     Frees its job, and the lab's rules then decide.
 //   GET   /contacts?q=&limit=         customers, by name
 //   GET   /price-items?q=             the price list, by code
 //   GET   /jobs?view=&limit=          billable jobs (the obligation ledger), with counts by view;
@@ -124,7 +130,7 @@ const MAX_UNIT_CENTS = 100_000_000;
 
 const ERROR_STATUS = {
   invalid: 400, organisation_required: 400, not_found: 404, not_draft: 409, not_issued: 409,
-  never_issued: 409, not_ready: 409, live_check_unavailable: 409, conflict: 409,
+  never_issued: 409, was_issued: 409, not_ready: 409, live_check_unavailable: 409, conflict: 409,
   accounting_not_connected: 409, accounting_writes_off: 409,
 };
 
@@ -449,17 +455,43 @@ export function createInvoicingRouter({
       const pattern = containing(q);
       where.push(or(ilike(invoices.number, pattern), ilike(invoices.reference, pattern), ilike(contacts.name, pattern)));
     }
-    // First the few columns the filter and sort read, for every row; then
-    // the whole rows of the one page.
-    const light = (await db.select({
+    // First the columns the filter and sort read, for every row; then the
+    // whole rows of the one page. A job column and a custom field read the
+    // invoice's job, so those values are on every row before the page is cut.
+    const lightRows = await db.select({
       id: invoices.id, number: invoices.number, reference: invoices.reference, issueDate: invoices.issueDate,
-      createdAt: invoices.createdAt, totalCents: invoices.totalCents, contactName: contacts.name,
+      dueDate: invoices.dueDate, createdAt: invoices.createdAt, totalCents: invoices.totalCents, contactName: contacts.name,
     }).from(invoices)
       .leftJoin(contacts, eq(contacts.id, invoices.contactId))
       .where(and(...where))
-      .orderBy(desc(invoices.createdAt), desc(invoices.id)))
-      .map((row) => ({ ...row, problems: tabs.problems.get(row.id) ?? [] }));
-    const page = invoicePage(light, { view, sort, dir, offset, limit, today: day });
+      .orderBy(desc(invoices.createdAt), desc(invoices.id));
+    const jobs = await jobsByInvoice(db, organisationId, lightRows.map((r) => r.id));
+    const customOn = filterRows(view).some((f) => fieldIdOf(f.field));
+    const [fieldDefs, fieldValues] = customOn
+      ? await Promise.all([
+        listFields(db, organisationId),
+        listJobFieldValues(db, organisationId, { jobs: [...jobs.values()].filter(Boolean) }),
+      ])
+      : [[], []];
+    const valuesOf = new Map();
+    for (const v of fieldValues) {
+      const key = `${v.sourceSystem}\u0000${v.sourceJobRef}`;
+      const bag = valuesOf.get(key) ?? {};
+      bag[v.fieldId] = v.value;
+      valuesOf.set(key, bag);
+    }
+    const light = lightRows.map((row) => {
+      const job = jobs.get(row.id) ?? null;
+      return {
+        ...row,
+        problems: tabs.problems.get(row.id) ?? [],
+        tab: tabs.tabOf.get(row.id) ?? null,
+        sending: tabs.sending.has(row.id),
+        job,
+        fields: job ? valuesOf.get(`${job.sourceSystem}\u0000${job.sourceJobRef}`) ?? {} : {},
+      };
+    });
+    const page = invoicePage(light, { view, sort, dir, offset, limit, today: day, kindOf: invoiceKindOf(fieldDefs), me: req.person.id });
     const pageIds = page.rows.map((r) => r.id);
     const full = pageIds.length
       ? await db.select({ invoice: invoices, contactName: contacts.name }).from(invoices)
@@ -468,7 +500,6 @@ export function createInvoicingRouter({
       : [];
     const byId = new Map(full.map((r) => [r.invoice.id, r]));
     const rows = pageIds.map((id) => byId.get(id)).filter(Boolean);
-    const jobs = await jobsByInvoice(db, organisationId, rows.map((r) => r.invoice.id));
     const systems = work();
     res.json({
       ok: true,
@@ -486,8 +517,9 @@ export function createInvoicingRouter({
       limit,
       total: page.total,
       totalCents: page.totalCents,
-      // The Filter chip's Client choices: every client of the tab.
+      // The Filter chip's choices, from every row of the tab.
       clients: [...new Set(light.map((r) => r.contactName).filter(Boolean))].sort((a, b) => a.localeCompare(b)),
+      practitioners: [...new Set(light.map((r) => r.job?.practitioner).filter(Boolean))].sort((a, b) => a.localeCompare(b)),
       sendsTo: system?.name ?? null,
       sendMode: mode,
       // The Linked column: one icon for each connected system.
@@ -593,8 +625,8 @@ export function createInvoicingRouter({
     // the job at its source or adopt the change (ledger.js), as Move to
     // Ready and Send do.
     const { problems } = await invoiceView(db, organisationId, await getInvoice(db, organisationId, invoiceId));
-    // A lab's pending rule (invoice-rules.js) is a gate too: fix its cause
-    // or turn the rule off.
+    // A lab's pending rule, or a skip rule the job matches (invoice-rules.js),
+    // is a gate too: fix its cause, void the draft, or turn the rule off.
     const held = problems.find((p) => p.code === 'job_review' || p.code === 'rule');
     if (held) throw new FlowError('not_ready', `${held.message.replace(/\.?$/, '.')} Nothing was approved.`);
     const issued = await issueInvoice(db, organisationId, invoiceId, { issuedBy: `person:${req.person.id}`, issueDate });
@@ -618,6 +650,14 @@ export function createInvoicingRouter({
     res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting(), work()) });
   }));
 
+  router.delete('/invoices/:id', ...manager, handle(log, async (req, res) => {
+    const invoiceId = pathId(req.params.id, 'invoice');
+    const organisationId = await organisationOf(req);
+    await deleteDraft(db, organisationId, invoiceId, { actor: `person:${req.person.id}` });
+    log.info?.(`[invoicing] organisation ${organisationId}: person ${req.person.id} deleted draft invoice ${invoiceId}`);
+    res.json({ ok: true });
+  }));
+
   router.get('/contacts', ...signedIn, handle(log, async (req, res) => {
     const organisationId = await organisationOf(req);
     const q = text(req.query.q);
@@ -842,7 +882,7 @@ export function createInvoicingRouter({
     res.json({
       ok: true,
       fields: Object.entries(FIELDS).map(([key, f]) => ({
-        key, label: f.label, kind: f.kind, options: f.options ?? null, tests: TESTS[f.kind], draftOnly: Boolean(f.draftOnly),
+        key, label: f.label, kind: f.kind, options: f.options ?? null, tests: f.tests ?? TESTS[f.kind], draftOnly: Boolean(f.draftOnly),
       })),
       actions: ACTIONS,
       options: {

package/server/auth/people.js

@@ -4,6 +4,7 @@ import { FlowError } from '../core/errors.js';
 import { isThemeFamily, normalizeAccent } from '../theme/themes.js';
 import { invoiceColumnsView, normaliseJobsView, normaliseListView, PRICE_COLUMNS, RECONCILE_COLUMNS } from '../ui/job-view.js';
 import { normaliseSavedViews, SAVED_VIEW_PAGES } from '../ui/list-views.js';
+import { normaliseNavPins } from '../ui/nav-pins.js';
 import { isPlainEmail } from './settings.js';
 
 // The people who may sign in, and their roles. Only an owner changes this
@@ -61,10 +62,11 @@ function viewCheck(page) {
     case 'invoices': return invoiceColumnsView;
     case 'reconcile': return (view) => normaliseListView(view, RECONCILE_COLUMNS);
     case 'price-list': return (view) => normaliseListView(view, PRICE_COLUMNS);
+    case 'nav': return normaliseNavPins;
     default: return null;
   }
 }
-const VIEW_PAGE_NAMES = ['jobs', 'invoices', 'reconcile', 'price-list'];
+const VIEW_PAGE_NAMES = ['jobs', 'invoices', 'reconcile', 'price-list', 'nav'];
 
 // A person's saved views as Flow sends them: only the known pages, each
 // checked, so a view saved by an older Flow still loads.

package/server/auth/routes.js

@@ -19,6 +19,7 @@ import {
 } from './people.js';
 import { isPlainEmail } from './settings.js';
 import { APP_PATHS, appPage } from '../ui/app-page.js';
+import { navPinsFromViews } from '../ui/nav-pins.js';
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const ERROR_STATUS = { invalid: 400, forbidden: 403, not_found: 404, conflict: 409 };
 
@@ -104,6 +105,8 @@ export function createSignInRouter({ settings, db, clerk, personAuth, defaultFam
     }
     body.appearance = req.person.appearance ? normaliseAppearance(req.person.appearance) : null;
     body.views = normaliseViews(req.person.views);
+    // No pins saved yet: today's sidebar. A saved choice is checked the same way.
+    body.views.nav = navPinsFromViews(req.person.views);
     res.json(body);
   });
 
@@ -118,7 +121,7 @@ export function createSignInRouter({ settings, db, clerk, personAuth, defaultFam
   });
 
   // Each person sets their own view of a page (how Jobs groups, sorts and
-  // filters); it follows their account.
+  // filters, and which pages are pinned: `nav`). It follows their account.
   router.put('/api/me/views/:page', requireSession, express.json({ limit: '8kb' }), async (req, res) => {
     try {
       const view = await setPersonView(db, { id: req.person.id, page: req.params.page, view: req.body });

package/server/core/invoice-rules.js

@@ -47,7 +47,14 @@ export const FIELDS = Object.freeze({
   practitioner: { label: 'Practitioner', kind: 'text', options: 'practitioners', read: (j, { customer }) => j.practitioner || customer.defaultPractitioner || null },
   // Only a draft has a Reference, so only a pending rule may read it.
   reference: { label: 'Reference', kind: 'text', draftOnly: true, read: (j) => j.reference || null },
-  customer: { label: 'Customer', kind: 'choice', options: 'customers', read: (j) => j.contactId },
+  // Menu tests read the contact id. Contains and does not contain read the
+  // customer's name (matches): a lab can exclude every name that contains
+  // one marker, so a new branch needs no new rule.
+  customer: {
+    label: 'Customer', kind: 'choice', options: 'customers',
+    tests: ['is', 'is_not', 'is_one_of', 'contains', 'does_not_contain', 'is_empty'],
+    read: (j) => j.contactId,
+  },
   customer_billable: { label: 'Customer is billable', kind: 'boolean', read: (j, { customer }) => customer.billable !== false },
   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 ?? [] },
@@ -71,7 +78,8 @@ function readCondition(raw, index) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw invalid(`condition ${index + 1} must be an object`);
   const field = FIELDS[raw.field];
   if (!field) throw invalid(`condition ${index + 1}: unknown field ${raw.field}`);
-  if (!TESTS[field.kind].includes(raw.test)) throw invalid(`condition ${index + 1}: ${field.label} takes ${TESTS[field.kind].join(', ')}`);
+  const allowed = field.tests ?? TESTS[field.kind];
+  if (!allowed.includes(raw.test)) throw invalid(`condition ${index + 1}: ${field.label} takes ${allowed.join(', ')}`);
   const out = { field: raw.field, test: raw.test };
   if (NO_VALUE.has(raw.test)) return out;
   const { value } = raw;
@@ -125,9 +133,13 @@ function matches(condition, job, context) {
   const { test, value } = condition;
   if (test === 'is_empty') return have === null || have === '' || have === undefined;
   if (test === 'is_not_empty') return !(have === null || have === '' || have === undefined);
-  if (field.kind === 'text' && !['is', 'is_not', 'is_one_of'].includes(test)) {
+  // Customer contains reads the contact's name, in any case and with the
+  // spaces trimmed, the same way a practitioner's name is read. is, is not
+  // and is one of still compare the contact id. `customer.name` is that name.
+  const named = condition.field === 'customer' && (test === 'contains' || test === 'does_not_contain');
+  if ((field.kind === 'text' || named) && !['is', 'is_not', 'is_one_of'].includes(test)) {
     // An empty text matches no test that reads its words; is_empty finds it.
-    const left = norm(have);
+    const left = norm(named ? (context.customer?.name ?? job.customerName ?? null) : have);
     if (!left) return false;
     if (test === 'is_not_one_of') return !value.some((v) => norm(v) === left);
     if (test === 'has_number') return /\d/.test(left);
@@ -195,6 +207,24 @@ export function rulePending(rules, job, { customer = {}, now = new Date() } = {}
     .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))] }));
 }
 
+// Drafts an enabled skip rule matches stay on Pending at Send (sending.js).
+// 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 };
+  return rules
+    .filter((r) => r.enabled && r.trigger === 'job_ready' && r.action.kind === 'skip')
+    .filter((r) => r.conditions.every((c) => matches(c, job, context)))
+    .map((r) => ({
+      code: 'rule',
+      message: `Rule "${r.name}": not invoiced. Void this draft or change the rule.`,
+      short: r.name.slice(0, 40),
+      rule: r.id ?? null,
+      fields: [...new Set(r.conditions.map((c) => c.field))],
+    }));
+}
+
 // The starter rules made from the earlier fixed settings.
 export function starterRules(settings) {
   const rules = [

package/server/core/invoices.js

@@ -1,5 +1,5 @@
 import { and, asc, desc, eq, sql } from 'drizzle-orm';
-import { contacts, invoiceLines, invoices, invoiceVersions, organisations, priceItems } from '../db/schema.js';
+import { billingObligations, contacts, invoiceLines, invoices, invoiceVersions, obligationEvents, organisations, priceItems } from '../db/schema.js';
 import { FlowError, notFound } from './errors.js';
 import { invoiceTotals, lineTotals } from './money.js';
 
@@ -7,6 +7,7 @@ import { invoiceTotals, lineTotals } from './money.js';
 // invoice its number and stores the document exactly as sent, as a new
 // version. To change an issued invoice, revise it back to a draft and issue
 // it again: the number stays and the earlier versions stay as they were.
+// A draft that was never issued can be deleted. An issued invoice is voided.
 
 async function loadInvoice(tx, organisationId, invoiceId, { lock = false } = {}) {
   let query = tx.select().from(invoices)
@@ -182,6 +183,44 @@ export async function voidInvoice(db, organisationId, invoiceId) {
   });
 }
 
+// Removes a draft that was never issued. The job it billed is free again:
+// its obligation no longer points at the draft, so the lab's rules decide
+// whether Flow drafts it once more. An invoice that was issued is voided,
+// not deleted (the database holds the same rule).
+export async function deleteDraft(db, organisationId, invoiceId, { actor = null } = {}) {
+  return db.transaction(async (tx) => {
+    const invoice = await loadInvoice(tx, organisationId, invoiceId, { lock: true });
+    if (invoice.status !== 'draft' || invoice.issuedVersion !== 0) {
+      throw new FlowError('was_issued', 'an invoice that was issued cannot be deleted; void it');
+    }
+    const linked = await tx.select().from(billingObligations)
+      .where(and(eq(billingObligations.organisationId, organisationId), eq(billingObligations.invoiceId, invoice.id)))
+      .for('update');
+    if (linked.length && !actor) throw new FlowError('invalid', 'actor is required');
+    for (const obligation of linked) {
+      await tx.update(billingObligations)
+        .set({ invoiceId: null, draftBasis: null, updatedAt: sql`now()` })
+        .where(eq(billingObligations.id, obligation.id));
+      await tx.insert(obligationEvents).values({
+        createdAt: sql`clock_timestamp()`,
+        organisationId,
+        obligationId: obligation.id,
+        kind: 'draft_deleted',
+        actor,
+        evidence: { invoiceId: invoice.id },
+      });
+    }
+    try {
+      await tx.delete(invoices).where(eq(invoices.id, invoice.id));
+    } catch (error) {
+      const code = error?.code ?? error?.cause?.code;
+      if (code === '23503') throw new FlowError('conflict', 'this draft is still linked; remove the link, then delete it');
+      throw error;
+    }
+    return invoice;
+  });
+}
+
 export async function getInvoice(db, organisationId, invoiceId) {
   const invoice = await loadInvoice(db, organisationId, invoiceId);
   const lines = await db.select().from(invoiceLines)

package/server/core/invoicing-rules.js

@@ -150,6 +150,16 @@ export async function customerBillingByContact(db, organisationId, contactIds) {
   return new Map(rows.map((r) => [r.contactId, pick(r, CUSTOMER_KEYS)]));
 }
 
+// The customers' names, by contact id. Customer "contains" reads the name
+// (invoice-rules.js), not the contact id the menu tests use.
+async function customerNames(db, organisationId, contactIds) {
+  const ids = [...new Set(contactIds.filter(Boolean))];
+  if (!ids.length) return new Map();
+  const rows = await db.select({ id: contacts.id, name: contacts.name }).from(contacts)
+    .where(and(eq(contacts.organisationId, organisationId), inArray(contacts.id, ids)));
+  return new Map(rows.map((r) => [r.id, r.name]));
+}
+
 // The settings that apply to one customer: its own, else the organisation's.
 // `autoDraft` is the customer's own switch for the draft automation.
 export function effectiveSettings(settings, customer = CUSTOMER_DEFAULTS) {
@@ -255,13 +265,16 @@ export async function autoDraftJobs(db, organisationId, { accounting = null, wor
     sql`${billingObligations.contactId} is not null`,
     // Newest first: a backlog of jobs that wait on a rule never hides new work.
   )).orderBy(sql`${billingObligations.jobDate} desc nulls last`, billingObligations.id).limit(limit);
-  const customers = await customerBillingByContact(db, organisationId, candidates.map((o) => o.contactId));
+  const contactIds = candidates.map((o) => o.contactId);
+  const customers = await customerBillingByContact(db, organisationId, contactIds);
+  const names = await customerNames(db, organisationId, contactIds);
+  const named = (contactId) => ({ ...effectiveSettings(settings, customers.get(contactId)), name: names.get(contactId) ?? null });
   const liveCheck = accounting ? copyCheck(accounting, organisationId) : null;
   const invoiceDate = isoDay(now);
   let accountingRead = null;
 
   for (const candidate of candidates) {
-    let effective = effectiveSettings(settings, customers.get(candidate.contactId));
+    let effective = named(candidate.contactId);
     if (!effective.autoDraft) {
       result.off += 1;
       continue;
@@ -302,7 +315,11 @@ export async function autoDraftJobs(db, organisationId, { accounting = null, wor
       }
     }
     if (obligation !== candidate) {
-      effective = effectiveSettings(settings, customers.get(obligation.contactId));
+      if (obligation.contactId && !names.has(obligation.contactId)) {
+        const extra = await customerNames(db, organisationId, [obligation.contactId]);
+        for (const [id, name] of extra) names.set(id, name);
+      }
+      effective = named(obligation.contactId);
       if (!effective.autoDraft || ruleBlockers(obligation, effective, { now, rules }).length) {
         result.waiting += 1;
         continue;

package/server/core/job-board.js

@@ -55,7 +55,7 @@ export async function describeObligations(db, organisationId, listed, { accounti
   // The invoicing rules a job with no invoice waits on, for every view a
   // draft can still come from.
   const waitingFor = (o, v) => (o.invoiceId || !['in_work', 'ready', 'pending', 'held'].includes(v)
-    ? [] : ruleBlockers(o, effectiveSettings(settings, customers.get(o.contactId)), { rules }));
+    ? [] : ruleBlockers(o, { ...effectiveSettings(settings, customers.get(o.contactId)), name: nameOf.get(o.contactId) ?? null }, { rules }));
   return listed.map(({ obligation: { lineFingerprint: _fingerprint, organisationId: _org, draftBasis: _basis, ...o }, view, reasons }) => ({
     ...o,
     canUseNewLines: offers.has(o.id),

package/server/core/sending.js

@@ -1,8 +1,8 @@
 import { randomUUID } from 'node:crypto';
 import { and, asc, desc, eq, inArray, sql } from 'drizzle-orm';
-import { billingObligations, invoiceLines, invoices } from '../db/schema.js';
+import { billingObligations, contacts, invoiceLines, invoices } from '../db/schema.js';
 import { FlowError } from './errors.js';
-import { listRules, rulePending } from './invoice-rules.js';
+import { listRules, rulePending, ruleSkip } from './invoice-rules.js';
 import { customerBillingByContact, effectiveSettings, readInvoicingSettings } from './invoicing-rules.js';
 import { issueInvoice } from './invoices.js';
 import { CHANGED_REASON, diffJobLines, STATUS_BACK_REASON } from './ledger.js';
@@ -17,7 +17,9 @@ import { deadHoldSince, deadSince, enqueueJob, runNextJob } from './queue.js';
 // 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), and the lab's pending
-// rules (invoice-rules.js) add their notes. A draft with a problem is
+// rules (invoice-rules.js) add their notes. An enabled skip rule does too:
+// a draft whose job it matches stays Pending, even when the draft was made
+// by hand or before the rule existed. A draft with a problem is
 // Pending (the "problem" view). A draft without one is Ready.
 //
 // Send all ready issues every ready draft (each gets its number) and, when an
@@ -81,19 +83,21 @@ async function checkDrafts(db, organisationId, drafts, accounting) {
     const found = draftProblems(draft, linesOf.get(draft.id) ?? []);
     if (found.length) problems.set(draft.id, found);
   }
-  const jobs = await db.select({ obligation: billingObligations, reference: invoices.reference }).from(billingObligations)
+  const jobs = await db.select({ obligation: billingObligations, reference: invoices.reference, customerName: contacts.name }).from(billingObligations)
     .innerJoin(invoices, eq(invoices.id, billingObligations.invoiceId))
+    .leftJoin(contacts, and(eq(contacts.id, billingObligations.contactId), eq(contacts.organisationId, billingObligations.organisationId)))
     .where(and(eq(billingObligations.organisationId, organisationId), inArray(billingObligations.invoiceId, ids)));
-  // The lab's pending rules (invoice-rules.js): a draft from a job that
-  // matches one waits on Pending with the rule's note, such as a Reference
-  // with no real practitioner.
-  const rules = (await listRules(db, organisationId)).filter((r) => r.enabled && r.action.kind === 'pending');
+  // The lab's rules (invoice-rules.js). A pending rule puts its note on the
+  // draft. A skip rule holds a draft that already exists: void it, or change
+  // the rule. Matching stays in invoice-rules.js.
+  const rules = (await listRules(db, organisationId)).filter((r) => r.enabled && (r.action.kind === 'pending' || r.action.kind === 'skip'));
   if (rules.length && jobs.length) {
     const settings = await readInvoicingSettings(db, organisationId);
     const customers = await customerBillingByContact(db, organisationId, jobs.map((j) => j.obligation.contactId));
-    for (const { obligation, reference } of jobs) {
-      const customer = effectiveSettings(settings, customers.get(obligation.contactId));
-      const found = rulePending(rules, { ...obligation, reference }, { customer });
+    for (const { obligation, reference, customerName } of jobs) {
+      const customer = { ...effectiveSettings(settings, customers.get(obligation.contactId)), name: customerName ?? null };
+      const job = { ...obligation, reference };
+      const found = [...rulePending(rules, job, { customer }), ...ruleSkip(rules, job, { customer })];
       if (found.length) problems.set(obligation.invoiceId, [...(problems.get(obligation.invoiceId) ?? []), ...found]);
     }
   }
@@ -196,23 +200,61 @@ async function assertCanSend(accounting, organisationId) {
 // Read before act (issue #141): the jobs behind these drafts whose work
 // system report is old are read again first. Answers the drafts that may go
 // now; a draft whose job went to review, or could not be read, waits.
+// `stops` names each held draft: `unread` (read failed or past the cap) or
+// `review` (the job changed).
 async function readJobsFirst(db, organisationId, invoiceIds, { work, now, personId }) {
-  if (!invoiceIds.length || typeof work?.capabilities?.readWorkItem !== 'function') return { go: invoiceIds, waiting: [] };
+  if (!invoiceIds.length || typeof work?.capabilities?.readWorkItem !== 'function') {
+    return { go: invoiceIds, waiting: [], stops: [] };
+  }
   const jobs = await db.select().from(billingObligations)
     .where(and(eq(billingObligations.organisationId, organisationId), inArray(billingObligations.invoiceId, invoiceIds)));
   const old = jobs.filter((job) => needsRead(job, { work, now }));
   const outcomes = await readBeforeAct(db, organisationId, old.slice(0, READS_PER_PASS), { work, now, actor: `person:${personId}` });
-  const held = new Set(old.slice(READS_PER_PASS).map((job) => job.invoiceId));
+  const held = new Set();
+  const stops = [];
+  for (const job of old.slice(READS_PER_PASS)) {
+    held.add(job.invoiceId);
+    stops.push({ invoiceId: job.invoiceId, kind: 'deferred' });
+  }
   for (const { outcome, obligation } of outcomes.values()) {
-    if (outcome === 'waiting' || outcome === 'review') held.add(obligation.invoiceId);
+    if (outcome === 'waiting') {
+      held.add(obligation.invoiceId);
+      stops.push({ invoiceId: obligation.invoiceId, kind: 'unread' });
+    } else if (outcome === 'review') {
+      held.add(obligation.invoiceId);
+      stops.push({ invoiceId: obligation.invoiceId, kind: 'review' });
+    }
+  }
+  return { go: invoiceIds.filter((id) => !held.has(id)), waiting: invoiceIds.filter((id) => held.has(id)), stops };
+}
+
+// The error when a ticked press sends nothing: name the cause (and the count
+// for jobs), never one shared sentence.
+function stoppedSendMessage({ accountingWaiting, accountingReason, stops, waiting }) {
+  if (accountingWaiting) {
+    if (accountingReason && /more changes than one read takes/i.test(accountingReason)) {
+      return 'The accounting copy has more changes than one read takes. Nothing was sent.';
+    }
+    if (accountingReason) return `${accountingReason.replace(/\.?$/, '')}. Nothing was sent.`;
+    return 'The accounting copy could not be read. Nothing was sent.';
+  }
+  const unread = stops.filter((stop) => stop.kind === 'unread').length;
+  const reviews = stops.filter((stop) => stop.kind === 'review').length;
+  if (unread) {
+    return `${unread} ${unread === 1 ? 'job' : 'jobs'} could not be read from the work system. Nothing was sent.`;
+  }
+  if (reviews) {
+    return `${reviews} ${reviews === 1 ? 'job' : 'jobs'} changed and ${reviews === 1 ? 'needs' : 'need'} a look. Nothing was sent.`;
   }
-  return { go: invoiceIds.filter((id) => !held.has(id)), waiting: invoiceIds.filter((id) => held.has(id)) };
+  const n = waiting.length || 1;
+  return `${n} ${n === 1 ? 'job' : 'jobs'} could not be confirmed with the work system. Nothing was sent.`;
 }
 
 // Send all ready: issues each ready draft, then queues it for the accounting
-// system. With `invoiceIds`, only those drafts, and each must be ready (the
-// Send button on one invoice). `work` is the work integration, for the read
-// before act. Answers { issued, queued, remaining, waiting }.
+// system. With `invoiceIds`, only those drafts. One id (the invoice page) is
+// all or nothing. More than one id (the bulk bar) sends the ones Flow could
+// confirm and leaves the rest. `work` is the work integration, for the read
+// before act. Answers { issued, queued, remaining, waiting, held }.
 export async function sendAllReady(db, organisationId, { accounting = null, work = null, personId, issueDate, invoiceIds = null, now = new Date() }) {
   await assertCanSend(accounting, organisationId);
   // Issue #45: the accounting copy reads its latest changes first, so the
@@ -236,11 +278,23 @@ export async function sendAllReady(db, organisationId, { accounting = null, work
         : 'Only a ready invoice can be sent. Mark it ready first.');
     }
   }
-  const { go, waiting } = accountingRead.outcome === 'waiting'
-    ? { go: [], waiting: ready.slice(0, SEND_BATCH) }
+  const accountingWaiting = accountingRead.outcome === 'waiting';
+  const { go, waiting, stops } = accountingWaiting
+    ? { go: [], waiting: ready.slice(0, SEND_BATCH), stops: [] }
     : await readJobsFirst(db, organisationId, ready.slice(0, SEND_BATCH), { work, now, personId });
-  if (invoiceIds && waiting.length) {
-    throw new FlowError('not_ready', 'Flow could not confirm the job with the work system or the accounting system just now, or the job changed. Nothing was sent. Look at the invoice, then try again.');
+  // One invoice (the invoice page) is all or nothing: a job Flow could not
+  // confirm stops the send. A bulk press sends the ones it confirmed. The
+  // rest stay for the next press (`waiting`), or on Pending when the read
+  // sent the job to review. An accounting read that cannot run still stops
+  // every ticked invoice: that one read covers the whole press. When nothing
+  // can go, the error names the cause and the count.
+  if (invoiceIds && waiting.length && go.length === 0) {
+    throw new FlowError('not_ready', stoppedSendMessage({
+      accountingWaiting,
+      accountingReason: accountingRead.reason,
+      stops,
+      waiting,
+    }));
   }
   const batch = go;
   let issued = 0;