@arcforgelabs/flow 2026.10.51 → 2026.10.53-1

package/npm-shrinkwrap.json

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

package/package.json

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

package/server/api/captures.js

@@ -1,13 +1,15 @@
 import express from 'express';
 import {
-  MAX_PHOTO_BYTES, captureView, decideCapture, readCapture, readCapturePhoto, typeProposal, uploadCapture,
+  MAX_PHOTO_BYTES, captureView, decideCapture, listCaptures, matchCapture, readCapture, readCapturePhoto, typeProposal, uploadCapture,
 } from '../core/captures.js';
 import { FlowError } from '../core/errors.js';
 import { resolveOrganisation } from './invoicing.js';
 
 // Photo capture (server/core/captures.js). A signed-in person uploads one
 // photo. The reader, when it is on, reads it after the response. When it is
-// off, the capture is a problem a person can type. Logs from this router are
+// off, the capture is a problem a person can type. A read capture is matched
+// to a job on the Jobs board the first time it is opened, and again when a
+// person types the fields. Logs from this router are
 // a capture id and an error code, never the photo or the fields.
 
 const ERROR_STATUS = {
@@ -25,7 +27,10 @@ function respond(res, error) {
   return res.status(ERROR_STATUS[error.code] ?? 400).json({ ok: false, code: error.code, error: error.message });
 }
 
-export function createCapturesRouter({ db, storage, personAuth, log = console, publicOrigin = null, reader = null }) {
+// `jobsFor(organisationId)` answers the Jobs board's jobs for the matcher.
+export function createCapturesRouter({
+  db, storage, personAuth, log = console, publicOrigin = null, reader = null, jobsFor = async () => [],
+}) {
   const router = express.Router();
   const signedIn = [personAuth.requireSession];
 
@@ -79,8 +84,25 @@ export function createCapturesRouter({ db, storage, personAuth, log = console, p
 
   router.use(express.json({ limit: '32kb' }));
 
+  router.get('/', ...signedIn, handle(async (req, res) => {
+    const rows = await listCaptures(db, await organisationOf(req));
+    res.json({ ok: true, captures: rows.map((row) => captureView(row)) });
+  }));
+
   router.get('/:id', ...signedIn, handle(async (req, res) => {
-    const result = await readCapture(db, storage, await organisationOf(req), req.params.id, origin(req));
+    const organisationId = await organisationOf(req);
+    let result = await readCapture(db, storage, organisationId, req.params.id, origin(req));
+    if (result.capture.state === 'ready' && result.capture.read && !result.capture.match) {
+      result = await matchCapture(db, storage, organisationId, req.params.id, { jobs: await jobsFor(organisationId), baseUrl: origin(req) });
+    }
+    res.json({ ok: true, capture: captureView(result.capture, result.link) });
+  }));
+
+  router.post('/:id/match', ...signedIn, handle(async (req, res) => {
+    const organisationId = await organisationOf(req);
+    const result = await matchCapture(db, storage, organisationId, req.params.id, {
+      jobs: await jobsFor(organisationId), fields: req.body?.fields ?? null, baseUrl: origin(req),
+    });
     res.json({ ok: true, capture: captureView(result.capture, result.link) });
   }));
 

package/server/api/invoicing.js

@@ -74,7 +74,7 @@ import {
 //   PUT   /settings                   owner or admin: change some of them
 //   GET   /rules                      the lab's invoice rules, in order (server/core/invoice-rules.js)
 //   GET   /rule-fields                what a rule can name, and the menus of values
-//   POST  /rules                      owner or admin: a new rule { name, enabled, conditions, action }
+//   POST  /rules                      owner or admin: a new rule { name, icon, enabled, conditions, action }
 //   PUT   /rules/:id                  owner or admin: change some of a rule
 //   DELETE /rules/:id                 owner or admin
 //   GET   /line-mappings              the lab's line mappings and the mapping steps (server/core/line-mapping.js)

package/server/app.js

@@ -7,6 +7,7 @@ import { createConnectorApi } from './api/connector.js';
 import { createInvoicingRouter } from './api/invoicing.js';
 import { createSignInRouter } from './auth/routes.js';
 import { integrationAlertsSource, invoiceProblemsSource, priceDifferencesSource } from './core/alerts.js';
+import { boardJobs } from './core/job-board.js';
 import { reconcileHealth } from './core/reconcile.js';
 import { appliedMigrationCounts } from './db/doctor.js';
 import { deployedBuildStatus } from './deployed-build.js';
@@ -158,6 +159,7 @@ export function createApp({
     if (storage) {
       app.use('/api/captures', createCapturesRouter({
         db: database.db, storage, personAuth: auth.personAuth, log, publicOrigin, reader,
+        jobsFor: async (organisationId) => (await boardJobs(database.db, organisationId, { work: work(), log })).jobs,
       }));
     }
     // Custom fields for jobs (server/core/custom-fields.js): kept in Flow

package/server/auth/people.js

@@ -2,8 +2,8 @@ import { and, asc, eq, isNull, ne, sql } from 'drizzle-orm';
 import { people, PERSON_ROLES } from '../db/schema.js';
 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 { invoiceColumnsView, normaliseJobsView, normaliseListView, RECONCILE_COLUMNS } from '../ui/job-view.js';
+import { normalisePriceView, normaliseSavedViews, SAVED_VIEW_PAGES } from '../ui/list-views.js';
 import { normaliseNavPins } from '../ui/nav-pins.js';
 import { isPlainEmail } from './settings.js';
 
@@ -61,7 +61,7 @@ function viewCheck(page) {
     case 'jobs': return normaliseJobsView;
     case 'invoices': return invoiceColumnsView;
     case 'reconcile': return (view) => normaliseListView(view, RECONCILE_COLUMNS);
-    case 'price-list': return (view) => normaliseListView(view, PRICE_COLUMNS);
+    case 'price-list': return normalisePriceView;
     case 'nav': return normaliseNavPins;
     default: return null;
   }

package/server/core/ai.js

@@ -1,4 +1,5 @@
 import { FlowError } from './errors.js';
+import { SURE_LINE } from '../ui/capture-fields.js';
 
 // The AI port. One call reads one image and returns text. The vision reader
 // (server/core/reader.js) is the caller. A client implements readImage; this
@@ -98,7 +99,7 @@ function priceFrom(env, model, prefix) {
 
 function sureLineOf(env) {
   const raw = String(env.FLOW_READER_SURE_LINE ?? '').trim();
-  if (!raw) return 0.8;
+  if (!raw) return SURE_LINE;
   const value = Number(raw);
   if (!Number.isFinite(value) || value < 0 || value > 1) throw new Error('FLOW_READER_SURE_LINE must be a number from 0 to 1');
   return value;

package/server/core/capture-match.js

@@ -0,0 +1,158 @@
+// The capture matcher (docs/DATA_MODEL.md, "Storage"). Flow code, not the
+// model, picks the job a form is about. It scores each job on the Jobs board
+// against the read or typed fields, in the style of the accounting link
+// suggestions: a score, a rank and the signals behind it. A person always
+// confirms the job before anything is applied.
+//
+// Points: case number 60 exact, 50 for a common misread (O for 0, l for 1),
+// practice and dentist 20, due date within 3 days 10, work or teeth found in
+// the job's lines 10.
+
+export const MATCH_POINTS = Object.freeze({ caseNumber: 60, caseMisread: 50, practice: 12, dentist: 8, date: 10, work: 10 });
+// A job at or above this, with no other job within SURE_GAP, is the one sure job.
+export const SURE_SCORE = 60;
+export const SURE_GAP = 20;
+// A job below this is not shown.
+export const SHOWN_SCORE = 20;
+const SHOWN_MAX = 5;
+const DATE_DAYS = 3;
+
+// Fields that find the job (the work is its lines). They are not proposed as
+// changes to a job that exists.
+const IDENTITY = new Set(['case_number', 'practice', 'work']);
+const MISREAD = { O: '0', Q: '0', D: '0', I: '1', L: '1', S: '5', B: '8', Z: '2', G: '6' };
+const NAME_NOISE = new Set(['dr', 'dental', 'dentist', 'dentistry', 'clinic', 'surgery', 'practice', 'centre', 'center', 'pty', 'ltd', 'the', 'and', 'of']);
+
+export const jobKey = (job) => `${job.sourceSystem}:${job.sourceJobRef}`;
+
+const plain = (value) => String(value ?? '').trim();
+const caseText = (value) => plain(value).toUpperCase().replace(/[^A-Z0-9]/g, '');
+const misread = (value) => caseText(value).replace(/[OQDILSBZG]/g, (ch) => MISREAD[ch]);
+
+function words(value) {
+  return plain(value).toLowerCase().replace(/[^a-z0-9 ]+/g, ' ').split(/\s+/)
+    .filter((word) => word.length > 1 && !NAME_NOISE.has(word));
+}
+
+// Edit distance, for close spelling of a name.
+function distance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i += 1) {
+    let previous = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j += 1) {
+      const kept = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1));
+      previous = kept;
+    }
+  }
+  return row[b.length];
+}
+
+const closeWord = (a, b) => a === b || (Math.min(a.length, b.length) >= 4 && distance(a, b) <= Math.floor(Math.max(a.length, b.length) / 4));
+
+// Half or more of the shorter name's words appear, by close spelling, in the other.
+export function sameName(read, known) {
+  const a = words(read);
+  const b = words(known);
+  if (!a.length || !b.length) return false;
+  const [short, long] = a.length <= b.length ? [a, b] : [b, a];
+  const found = short.filter((word) => long.some((other) => closeWord(word, other))).length;
+  return found * 2 >= short.length;
+}
+
+// A date as a lab writes it: 2026-10-31, 31/10/2026, 31/10/26 or 31/10 (day
+// first, as in Australia). A date with no year takes the year nearest `now`.
+export function readDate(value, now = new Date()) {
+  const text = plain(value);
+  let match = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(text);
+  if (match) return utc(+match[1], +match[2], +match[3]);
+  match = /^(\d{1,2})[/.-](\d{1,2})(?:[/.-](\d{2}|\d{4}))?$/.exec(text);
+  if (!match) return null;
+  const [, day, month, year] = match;
+  if (year) return utc(year.length === 2 ? 2000 + +year : +year, +month, +day);
+  const near = [-1, 0, 1].map((step) => utc(now.getUTCFullYear() + step, +month, +day)).filter(Boolean);
+  return near.sort((a, b) => Math.abs(a - now) - Math.abs(b - now))[0] ?? null;
+}
+
+function utc(year, month, day) {
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCMonth() === month - 1 && date.getUTCDate() === day ? date : null;
+}
+
+function teethOf(value) {
+  return plain(value).match(/\b[1-8][1-8]\b/g) ?? [];
+}
+
+function workFound(fields, job) {
+  const lines = (job.lines ?? []).map((line) => plain(line.description).toLowerCase()).join(' ');
+  if (!lines) return false;
+  const work = words(fields.work).filter((word) => word.length >= 4);
+  if (work.some((word) => lines.includes(word))) return true;
+  return teethOf(fields.teeth).some((tooth) => new RegExp(`\\b${tooth}\\b`).test(lines));
+}
+
+function score(fields, job, now) {
+  const signals = [];
+  const readCase = caseText(fields.case_number);
+  const jobCase = caseText(job.caseRef);
+  if (readCase && jobCase) {
+    if (readCase === jobCase) signals.push({ signal: 'case_number', points: MATCH_POINTS.caseNumber });
+    else if (misread(readCase) === misread(jobCase)) signals.push({ signal: 'case_number_misread', points: MATCH_POINTS.caseMisread });
+  }
+  if (sameName(fields.practice, job.clientName) || sameName(fields.practice, job.workClientName)) {
+    signals.push({ signal: 'practice', points: MATCH_POINTS.practice });
+  }
+  if (sameName(fields.dentist, job.practitioner)) signals.push({ signal: 'dentist', points: MATCH_POINTS.dentist });
+  const due = readDate(fields.due_date, now);
+  const jobDue = readDate(job.dueOn ?? job.jobDate, now);
+  if (due && jobDue && Math.abs(due - jobDue) <= DATE_DAYS * 86_400_000) signals.push({ signal: 'date', points: MATCH_POINTS.date });
+  if (workFound(fields, job)) signals.push({ signal: 'work', points: MATCH_POINTS.work });
+  return { score: signals.reduce((sum, s) => sum + s.points, 0), signals };
+}
+
+// `fields` is { key: value }. `jobs` is the Jobs board's jobs
+// (server/core/job-board.js). Answers { outcome, jobs }: outcome `sure` (one
+// job), `close` (a short pick list) or `none` (offer a new job).
+export function matchJobs(fields, jobs, { now = new Date() } = {}) {
+  const ranked = (jobs ?? [])
+    .map((job) => ({ job, ...score(fields, job, now) }))
+    .filter((entry) => entry.score >= SHOWN_SCORE)
+    .sort((a, b) => b.score - a.score || plain(a.job.sourceJobRef).localeCompare(plain(b.job.sourceJobRef)))
+    .slice(0, SHOWN_MAX);
+  const [top, next] = ranked;
+  const outcome = !top ? 'none'
+    : top.score >= SURE_SCORE && (!next || top.score - next.score >= SURE_GAP) ? 'sure' : 'close';
+  return {
+    outcome,
+    jobs: ranked.map(({ job, score: points, signals }) => ({
+      jobId: jobKey(job), caseRef: job.caseRef ?? null, clientName: job.clientName ?? null, score: points, signals,
+    })),
+  };
+}
+
+// What the job holds now for a read field, where the board shows it.
+function current(job, key) {
+  if (!job) return '';
+  if (key === 'dentist') return plain(job.practitioner);
+  if (key === 'due_date') return plain(job.dueOn);
+  return '';
+}
+
+// The proposed change from the fields and the match. One sure job: update it
+// with each field that differs. Close jobs: update, and the person picks the
+// job. No job: create one from the fields. A field the reader was not sure
+// of keeps its sure score, so the screen can mark it.
+export function proposeChange(read, match, jobs) {
+  const sure = match.outcome === 'sure' ? match.jobs[0] : null;
+  const job = sure ? (jobs ?? []).find((entry) => jobKey(entry) === sure.jobId) ?? null : null;
+  const changes = read
+    .filter((field) => plain(field.value) && (match.outcome === 'none' || !IDENTITY.has(field.key)))
+    .map((field) => ({ field: field.key, from: current(job, field.key), to: plain(field.value), sure: field.sure }))
+    .filter((change) => change.from !== change.to);
+  return {
+    action: match.outcome === 'none' ? 'create' : 'update',
+    jobId: sure?.jobId ?? null,
+    changes,
+  };
+}

package/server/core/captures.js

@@ -1,7 +1,10 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { and, eq, isNotNull, isNull, lt, sql } from 'drizzle-orm';
+import { and, desc, eq, gt, isNotNull, isNull, lt, or, sql } from 'drizzle-orm';
 import { CAPTURE_DECISIONS, captures } from '../db/schema.js';
 import { FlowError, notFound } from './errors.js';
+import { matchJobs, proposeChange, readDate } from './capture-match.js';
+import { listFields, listJobFieldValues, setJobFieldValue } from './custom-fields.js';
+import { JOB_FIELDS } from '../ui/capture-fields.js';
 
 // Shown when the module is off or the keys are missing. Type it still works.
 const READER_OFF = 'reader turned off';
@@ -10,8 +13,9 @@ const READER_OFF = 'reader turned off';
 // "Storage"). This does not change a job. The reader, when it is on, fills
 // `read` in the background (server/core/reader.js). When it is off, or the
 // keys are missing, the capture is `problem` ("reader turned off") and a
-// person can type the proposal. Apply or Discard records that decision and
-// deletes the photo. A capture nobody decides is deleted after 7 days,
+// person can type the proposal. A ready capture is matched to a job on the
+// Jobs board (server/core/capture-match.js), and the match proposes the
+// change. Apply or Discard records that decision and deletes the photo. A capture nobody decides is deleted after 7 days,
 // photo included.
 //
 // Nothing here writes the photo, the typed fields or a patient name to a log.
@@ -24,6 +28,8 @@ export const EMPTY_PROPOSAL = Object.freeze({ action: null, jobId: null, changes
 const PHOTO_TYPES = new Set(['image/jpeg', 'image/png', 'image/webp', 'image/heic', 'image/heif']);
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const ACTIONS = new Set(['update', 'create', 'note']);
+// A job on the Jobs board: its work system and its id there (capture-match.js jobKey).
+const JOB_ID = /^[a-z][a-z0-9_-]{0,39}:[^\u0000-\u001f]{1,200}$/;
 const FIELD_MAX = 60;
 const VALUE_MAX = 2000;
 const CHANGES_MAX = 40;
@@ -78,13 +84,14 @@ export function readProposal(input) {
   const action = input.action ?? null;
   if (action !== null && !ACTIONS.has(action)) throw invalid('action must be update, create or note');
   const jobId = input.jobId ?? null;
-  if (jobId !== null && !UUID.test(String(jobId))) throw invalid('jobId must be a job id');
+  if (jobId !== null && !JOB_ID.test(String(jobId))) throw invalid('jobId must be a job id');
   if (!Array.isArray(input.changes)) throw invalid('changes must be a list');
   if (input.changes.length > CHANGES_MAX) throw invalid('too many changes');
   const changes = input.changes.map((change) => ({
     field: readText(change?.field, FIELD_MAX),
     from: readText(change?.from ?? '', VALUE_MAX),
     to: readText(change?.to ?? '', VALUE_MAX),
+    ...(Number.isFinite(change?.sure) ? { sure: Math.min(1, Math.max(0, change.sure)) } : {}),
   }));
   if (changes.some((change) => !change.field)) throw invalid('a change needs a field');
   if (changes.length > 0 && !action) throw invalid('action is required');
@@ -102,6 +109,7 @@ export function captureView(row, link = null) {
     fileSha256: row.fileSha256,
     proposal: row.proposal ?? { ...EMPTY_PROPOSAL, changes: [] },
     read: row.read ?? null,
+    match: row.match ?? null,
     problem: row.problem,
     decision: row.decision,
     decidedAt: row.decidedAt,
@@ -221,6 +229,130 @@ export async function typeProposal(db, storage, organisationId, id, input, { bas
   return { capture: row, link: linkFor(storage, row, baseUrl) };
 }
 
+// What a person typed instead of a read: { key: value }, keys as the reader's.
+function readTypedFields(input) {
+  if (input == null || typeof input !== 'object' || Array.isArray(input)) throw invalid('fields must be an object');
+  const entries = Object.entries(input);
+  if (entries.length > CHANGES_MAX) throw invalid('too many fields');
+  return entries.map(([key, value]) => ({ key: readText(key, FIELD_MAX), value: readText(value ?? '', VALUE_MAX), seen: '', sure: 1 }));
+}
+
+const isEmpty = (proposal) => !proposal?.action && !(proposal?.changes?.length);
+
+// Scores the Jobs board against the read (or typed) fields, stores the match
+// and, when nobody has typed a change yet, the proposed change. Typed fields
+// always replace the proposal: the person asked for a new match. `jobs` is
+// the board's jobs (server/core/job-board.js boardJobs).
+export async function matchCapture(db, storage, organisationId, id, { jobs, fields = null, baseUrl, now } = {}) {
+  const current = await byId(db, organisationId, id);
+  if (current.state !== 'ready' && !(fields && current.state === 'problem')) throw new FlowError('conflict', 'this capture is not ready');
+  const read = fields ? readTypedFields(fields) : (current.read?.fields ?? []);
+  const values = Object.fromEntries(read.map((field) => [field.key, field.value]));
+  const match = matchJobs(values, jobs, { now });
+  const replace = Boolean(fields) || isEmpty(current.proposal);
+  const [row] = await db.update(captures).set({
+    state: 'ready',
+    problem: null,
+    match,
+    ...(replace ? { proposal: await toCustomFields(db, organisationId, proposeChange(read, match, jobs)) } : {}),
+    updatedAt: sql`now()`,
+  }).where(and(
+    eq(captures.organisationId, organisationId),
+    eq(captures.id, id),
+    eq(captures.state, current.state),
+  )).returning();
+  if (!row) throw new FlowError('conflict', 'this capture changed; open it again');
+  return { capture: row, link: linkFor(storage, row, baseUrl) };
+}
+
+// The capture tray: every capture still open, and the ones decided in the
+// last day, newest first. No signed link: the result sheet asks for one.
+export async function listCaptures(db, organisationId, { now = new Date(), limit = 100 } = {}) {
+  const since = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+  return db.select().from(captures).where(and(
+    eq(captures.organisationId, organisationId),
+    or(isNull(captures.decision), gt(captures.decidedAt, since)),
+  )).orderBy(desc(captures.createdAt)).limit(limit);
+}
+
+// A custom field's value from the text on the form. Undefined: Flow cannot
+// set this field from text (a person field), so it is left as it is.
+function fieldValue(field, text) {
+  const bad = () => invalid(`${field.name}: "${text}" does not fit this field`);
+  switch (field.type) {
+    case 'number': {
+      const number = Number(text.replace(/,/g, ''));
+      if (!Number.isFinite(number)) throw bad();
+      return number;
+    }
+    case 'date': {
+      const date = readDate(text);
+      if (!date) throw bad();
+      return date.toISOString().slice(0, 10);
+    }
+    case 'dropdown': {
+      const option = field.options.find((o) => !o.archived && o.name.toLowerCase() === text.toLowerCase());
+      if (!option) throw bad();
+      return option.id;
+    }
+    case 'checkbox':
+      if (/^(yes|y|true|x|✓|1)$/i.test(text)) return true;
+      if (/^(no|n|false|0)$/i.test(text)) return false;
+      throw bad();
+    case 'person':
+      return undefined;
+    default:
+      return text;
+  }
+}
+
+const jobOf = (jobId) => {
+  const at = jobId.indexOf(':');
+  return { sourceSystem: jobId.slice(0, at), sourceJobRef: jobId.slice(at + 1) };
+};
+
+// A custom field's stored value as the sheet shows it ("from").
+function shownValue(field, value) {
+  if (value == null) return '';
+  if (field.type === 'dropdown') return field.options?.find((option) => option.id === value)?.name ?? '';
+  if (field.type === 'checkbox') return value ? 'Yes' : 'No';
+  return String(value);
+}
+
+// A read field goes to the lab's custom field of the same name ("Shade")
+// when there is one: Flow owns it, so Apply writes it. Any other field stays
+// the work system's; the sheet marks it to change there (maintainer, #357).
+async function toCustomFields(db, organisationId, proposal) {
+  if (proposal.action !== 'update') return proposal;
+  const byName = new Map((await listFields(db, organisationId)).map((field) => [field.name.trim().toLowerCase(), field]));
+  const labels = new Map(JOB_FIELDS.map((field) => [field.key, field.label.toLowerCase()]));
+  const values = proposal.jobId
+    ? new Map((await listJobFieldValues(db, organisationId, { jobs: [jobOf(proposal.jobId)] })).map((row) => [row.fieldId, row.value]))
+    : new Map();
+  const changes = proposal.changes.map((change) => {
+    const field = byName.get(labels.get(change.field));
+    return field ? { ...change, field: `custom_${field.id}`, from: shownValue(field, values.get(field.id)) } : change;
+  }).filter((change) => change.from !== change.to);
+  return { ...proposal, changes };
+}
+
+// Apply writes what Flow owns: the job's custom fields, each with its own
+// event (who, when, from and to). A field the work system owns (due date,
+// shade) stays there; the result sheet links to the job in that system.
+// Every value is checked before the first write, so a bad one writes none.
+async function applyToJob(db, organisationId, proposal, personId) {
+  if (proposal?.action !== 'update' || !proposal.jobId) return;
+  const job = jobOf(proposal.jobId);
+  const fields = new Map((await listFields(db, organisationId)).map((field) => [`custom_${field.id}`, field]));
+  const writes = proposal.changes
+    .filter((change) => fields.has(change.field))
+    .map((change) => ({ field: fields.get(change.field), value: fieldValue(fields.get(change.field), change.to) }))
+    .filter((write) => write.value !== undefined);
+  for (const { field, value } of writes) {
+    await setJobFieldValue(db, organisationId, { ...job, fieldId: field.id, value }, { personId });
+  }
+}
+
 async function deletePhoto(db, storage, row) {
   if (row.photoDeletedAt) return row;
   try {
@@ -242,9 +374,10 @@ async function deletePhoto(db, storage, row) {
   return next ?? row;
 }
 
-// Records the person's decision and deletes the photo. It does not change a
-// job: matching and applying a change are later slices. The same decision
-// again deletes the photo if that was still waiting.
+// Records the person's decision and deletes the photo. Apply first writes
+// the job's custom fields (applyToJob). The same decision again writes the
+// same values, which changes nothing, and deletes the photo if that was
+// still waiting.
 export async function decideCapture(db, storage, organisationId, id, decision, { personId, baseUrl } = {}) {
   if (!CAPTURE_DECISIONS.includes(decision)) throw invalid('decision must be applied or discarded');
   const current = await byId(db, organisationId, id);
@@ -254,6 +387,7 @@ export async function decideCapture(db, storage, organisationId, id, decision, {
     return { capture: row, link: null };
   }
   if (current.state !== 'ready') throw new FlowError('conflict', 'this capture is not ready');
+  if (decision === 'applied') await applyToJob(db, organisationId, current.proposal, personId ?? null);
   const [row] = await db.update(captures).set({
     state: 'done',
     decision,

package/server/core/invoice-rules.js

@@ -1,3 +1,6 @@
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
 import { and, asc, eq, sql } from 'drizzle-orm';
 import { invoiceRules, invoicingSettings } from '../db/schema.js';
 import { FlowError, notFound } from './errors.js';
@@ -26,6 +29,10 @@ const MAX_CONDITIONS = 10;
 const invalid = (message) => new FlowError('invalid', message);
 
 const MAX_NOTE = 200;
+// A rule's own icon: any Lucide name (the icon picker, server/ui/kit.js).
+// Null shows the mark of what the rule does.
+const ICON_DIR = join(dirname(createRequire(import.meta.url).resolve('lucide-static/package.json')), 'icons');
+const ICON_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const day = (date) => new Date(`${String(date).slice(0, 10)}T00:00:00Z`);
 const norm = (value) => String(value ?? '').trim().replace(/\s+/g, ' ').toLowerCase();
 // A line's key: its price item code, else the label line mapping gave it (a
@@ -107,10 +114,14 @@ function readCondition(raw, index) {
 
 export function readRule(raw) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw invalid('the rule must be an object');
-  const unknown = Object.keys(raw).filter((k) => !['name', 'enabled', 'conditions', 'action'].includes(k));
+  const unknown = Object.keys(raw).filter((k) => !['name', 'icon', 'enabled', 'conditions', 'action'].includes(k));
   if (unknown.length) throw invalid(`unknown field: ${unknown[0]}`);
   const name = typeof raw.name === 'string' ? raw.name.trim() : '';
   if (!name || name.length > 120) throw invalid('the rule needs a name of 120 characters at most');
+  const icon = raw.icon ?? null;
+  if (icon !== null && (typeof icon !== 'string' || icon.length > 64 || !ICON_NAME.test(icon) || !existsSync(join(ICON_DIR, `${icon}.svg`)))) {
+    throw invalid('the icon must be a Lucide icon name');
+  }
   const enabled = raw.enabled ?? true;
   if (typeof enabled !== 'boolean') throw invalid('enabled must be true or false');
   if (!Array.isArray(raw.conditions) || !raw.conditions.length || raw.conditions.length > MAX_CONDITIONS) {
@@ -127,7 +138,7 @@ export function readRule(raw) {
     const early = conditions.find((c) => FIELDS[c.field].draftOnly);
     if (early) throw invalid(`${FIELDS[early.field].label} is on the draft only: use Then "Pending, with a note"`);
   }
-  return { name, enabled, conditions, action };
+  return { name, icon, enabled, conditions, action };
 }
 
 function matches(condition, job, context) {
@@ -270,7 +281,7 @@ async function seed(db, organisationId) {
 }
 
 const shape = (r) => ({
-  id: r.id, name: r.name, position: r.position, enabled: r.enabled, trigger: r.trigger,
+  id: r.id, name: r.name, icon: r.icon, position: r.position, enabled: r.enabled, trigger: r.trigger,
   conditions: r.conditions, action: r.action, starter: Boolean(r.starterKey), updatedAt: r.updatedAt,
 });
 
@@ -299,12 +310,12 @@ async function loadRule(db, organisationId, ruleId) {
   return row;
 }
 
-// Changes a rule. `changes` holds any of name, enabled, conditions, action;
+// Changes a rule. `changes` holds any of name, icon, enabled, conditions, action;
 // the result must be a whole valid rule.
 export async function updateRule(db, organisationId, ruleId, changes, { personId = null } = {}) {
   const row = await loadRule(db, organisationId, ruleId);
   if (!changes || typeof changes !== 'object' || Array.isArray(changes)) throw invalid('the change must be an object');
-  const rule = readRule({ name: row.name, enabled: row.enabled, conditions: row.conditions, action: row.action, ...changes });
+  const rule = readRule({ name: row.name, icon: row.icon, enabled: row.enabled, conditions: row.conditions, action: row.action, ...changes });
   const [saved] = await db.update(invoiceRules).set({ ...rule, updatedBy: personId, updatedAt: sql`now()` })
     .where(eq(invoiceRules.id, row.id)).returning();
   return shape(saved);

package/server/core/reader.js

@@ -4,6 +4,7 @@ import { callCostMicros } from './ai.js';
 import { captures, jobFields } from '../db/schema.js';
 import { FlowError } from './errors.js';
 import { enqueueJob, runNextJob } from './queue.js';
+import { JOB_FIELDS } from '../ui/capture-fields.js';
 
 // The vision reader. A small model reads every capture. A larger model reads
 // again only when case number, practice or work is below the sure line.
@@ -20,16 +21,6 @@ export const CAPTURE_READ_KIND = 'capture.read';
 const CALLS = 3;
 const VALUE_MAX = 2000;
 
-export const JOB_FIELDS = Object.freeze([
-  Object.freeze({ key: 'case_number', label: 'Case number', needed: true }),
-  Object.freeze({ key: 'practice', label: 'Practice', needed: true }),
-  Object.freeze({ key: 'dentist', label: 'Dentist', needed: false }),
-  Object.freeze({ key: 'work', label: 'Work', needed: true }),
-  Object.freeze({ key: 'teeth', label: 'Teeth', needed: false }),
-  Object.freeze({ key: 'shade', label: 'Shade', needed: false }),
-  Object.freeze({ key: 'due_date', label: 'Due date', needed: false }),
-  Object.freeze({ key: 'notes', label: 'Notes', needed: false }),
-]);
 
 const NEEDED = new Set(JOB_FIELDS.filter((field) => field.needed).map((field) => field.key));
 

package/server/core/sending.js

@@ -53,6 +53,10 @@ const SENT = new Set(['created', 'reconciled', 'existing', 'already_in_xero']);
 // it. `extra` adds `fields` (the invoice fields to fix) and `line`.
 const problem = (code, message, short = null, extra = {}) => ({ code, message, ...(short ? { short } : {}), ...extra });
 
+// An issued invoice the accounting system refused. A refusal stored without
+// its few words (before 2026-10-28) shows "Not sent"; its message stays.
+const refusal = (sendError) => (sendError ? { short: 'Not sent', ...sendError } : problem('send_failed', 'Sending failed.', 'Not sent'));
+
 // Flow's own checks of one draft. `lines` are its invoice lines.
 export function draftProblems(invoice, lines) {
   const problems = [];
@@ -155,7 +159,7 @@ export async function invoiceViews(db, organisationId, { accounting = null } = {
     .orderBy(desc(invoices.sendUpdatedAt));
   for (const row of issued) {
     if (row.sendState === 'queued') sending.add(row.id);
-    else problems.set(row.id, [row.sendError ?? problem('send_failed', 'Sending failed.', 'Send failed')]);
+    else problems.set(row.id, [refusal(row.sendError)]);
   }
   // A draft whose checks pass is ready (Samuel, 2026-10-20): no person
   // needs to mark it. toCheck stays for callers that still read it.
@@ -174,7 +178,7 @@ export async function invoiceView(db, organisationId, invoice, { accounting = nu
   if (invoice.status === 'void') return { view: null, problems: [] };
   if (invoice.status === 'issued') {
     if (invoice.sendState === 'queued') return { view: 'sending', problems: [] };
-    if (invoice.sendState === 'failed') return { view: 'problem', problems: [invoice.sendError ?? problem('send_failed', 'Sending failed.', 'Send failed')] };
+    if (invoice.sendState === 'failed') return { view: 'problem', problems: [refusal(invoice.sendError)] };
     return { view: null, problems: [] };
   }
   const found = (await checkDrafts(db, organisationId, [invoice], accounting)).get(invoice.id) ?? [];
@@ -435,7 +439,7 @@ export async function sendQueued(db, organisationId, { accounting, limit = WORKE
         summary.waiting += 1;
       } else {
         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 } });
+        await settle(db, organisationId, result.invoiceId, { sendState: 'failed', sendError: { code: error.code, message: error.message, ...(error.short ? { short: error.short } : {}) } });
         summary.failed += 1;
         summary.refused = [...new Set([...(summary.refused ?? []), error.code])];
         const fact = refusalFact(known.get(result.invoiceId), error);

package/server/db/migrations/0024_rule_icon.sql

@@ -0,0 +1,5 @@
+ALTER TABLE "invoice_rules" ADD COLUMN IF NOT EXISTS "icon" text;--> statement-breakpoint
+DO $flow_guard$ BEGIN
+	ALTER TABLE "invoice_rules" ADD CONSTRAINT "invoice_rules_icon_valid" CHECK ("invoice_rules"."icon" is null or (length("invoice_rules"."icon") between 1 and 64 and "invoice_rules"."icon" !~ '[^a-z0-9-]'));
+EXCEPTION WHEN duplicate_object OR duplicate_table OR invalid_table_definition THEN NULL;
+END $flow_guard$;