@arcforgelabs/flow 2026.10.51 → 2026.10.53-1

package/server/db/migrations/meta/_journal.json

@@ -169,6 +169,13 @@
       "when": 1793110575758,
       "tag": "0023_captures",
       "breakpoints": true
+    },
+    {
+      "idx": 24,
+      "version": "7",
+      "when": 1793233782043,
+      "tag": "0024_rule_icon",
+      "breakpoints": true
     }
   ]
-}
+}

package/server/db/schema.js

@@ -694,6 +694,8 @@ export const invoiceRules = pgTable('invoice_rules', {
   id: id(),
   organisationId: organisationId().references(() => organisations.id),
   name: text('name').notNull(),
+  // A Lucide icon name for the rule's card; null shows the action's mark.
+  icon: text('icon'),
   position: integer('position').notNull(),
   enabled: boolean('enabled').notNull().default(true),
   trigger: text('trigger').notNull().default('job_ready'),
@@ -707,6 +709,7 @@ export const invoiceRules = pgTable('invoice_rules', {
   uniqueIndex('invoice_rules_starter_key').on(t.organisationId, t.starterKey),
   check('invoice_rules_trigger_valid', sql`${t.trigger} in ('job_ready')`),
   check('invoice_rules_name_valid', sql`length(${t.name}) between 1 and 120`),
+  check('invoice_rules_icon_valid', sql`${t.icon} is null or (length(${t.icon}) between 1 and 64 and ${t.icon} !~ '[^a-z0-9-]')`),
 ]);
 
 // Automations (server/core/automations.js): Flow's routines, each on or off,

package/server/integrations/seazona/history/backfill.js

@@ -1,4 +1,4 @@
-import { and, eq, inArray } from 'drizzle-orm';
+import { eq, inArray } from 'drizzle-orm';
 import { FlowError } from '../../../core/errors.js';
 import { mapOrder, parseSeazonaDate, text } from '../map.js';
 import { seazonaHistoryBatchJobs, seazonaLaneState, seazonaOrders } from '../schema.js';
@@ -11,8 +11,9 @@ import { createApiBatch, finishApiBatch, stageApiJobs } from './index.js';
 // detail. It makes at most
 // `historyCallsPerRun` calls a run, through the same rate governor and call
 // guards as the live lanes, and keeps its place in the lane's cursor, so it
-// resumes after a restart. Orders the live copy already holds are not read
-// again. Each order becomes one job in an API batch: reconciled as it is
+// resumes after a restart. Orders the live copy already holds, and orders
+// any earlier backfill read, are not read again, so a read started again over
+// the same days costs only the list calls. Each order becomes one job in an API batch: reconciled as it is
 // read, written to Flow's history when it is new, and kept for a person when
 // it is not. The batch rows are the record of what the API confirmed.
 
@@ -65,7 +66,7 @@ export async function startBackfill(db, { from, through = null, createdBy, setti
     throw Object.assign(new FlowError('conflict', 'A history backfill is already running'), { status: 409 });
   }
   const batch = await createApiBatch(db, { createdBy, from, through: last, at });
-  const cursor = { batchId: batch.id, from, through: last, nextDay: from, page: 1, pending: [], done: false, days: 0, read: 0 };
+  const cursor = { batchId: batch.id, from, through: last, nextDay: from, page: 1, pending: [], done: false, days: 0, read: 0, startedAt: at.toISOString() };
   await db.insert(seazonaLaneState).values({ lane: LANE, status: 'idle', cursor, nextRunAt: at })
     .onConflictDoUpdate({ target: seazonaLaneState.lane, set: { status: 'idle', cursor, nextRunAt: at, failureCount: 0, lastError: null, heldReason: null, updatedAt: at } });
   return describeBackfill(cursor);
@@ -89,19 +90,47 @@ export function describeBackfill(cursor) {
     batchId: cursor.batchId,
     from: cursor.from,
     through: cursor.through,
+    startedAt: cursor.startedAt ?? null,
     nextDay: cursor.done ? null : cursor.nextDay,
+    // The day whose orders it reads now: the last day listed while orders
+    // from it wait, else the next day to list.
+    readingDay: cursor.done ? null : (cursor.pending?.length && cursor.listDay) || cursor.nextDay,
     daysDone: cursor.days ?? 0,
     reachedDay: cursor.reached ?? null,
     ordersRead: cursor.read ?? 0,
     waitingToRead: cursor.pending?.length ?? 0,
     running: !cursor.done,
     stopped: Boolean(cursor.stopped),
+    // Where a stopped read goes on: the day it listed last while orders from
+    // that list were still to read, else the next day.
+    resumeFrom: !cursor.stopped ? null
+      : cursor.pending?.length && cursor.listDay ? cursor.listDay
+        : cursor.nextDay <= cursor.through ? cursor.nextDay : null,
   };
 }
 
+// A read that failed this many runs in a row shows as failed, not waiting.
+const FAILED_AFTER = 3;
+
+// The card's phase. A held or failed lane waits for its retry at nextRunAt;
+// a lane Seazona halted, or one that failed FAILED_AFTER times, has failed.
+function phaseOf(backfill, state) {
+  if (!backfill.running) return backfill.stopped ? 'stopped' : 'done';
+  if (state.status === 'stopped' || (state.status === 'failed' && state.failureCount >= FAILED_AFTER)) return 'failed';
+  return ['held', 'failed'].includes(state.status) ? 'waiting' : 'running';
+}
+
 export async function readBackfill(db) {
   const [state] = await db.select().from(seazonaLaneState).where(eq(seazonaLaneState.lane, LANE));
-  return describeBackfill(state?.cursor);
+  const backfill = describeBackfill(state?.cursor);
+  if (!backfill) return null;
+  const phase = phaseOf(backfill, state);
+  return {
+    ...backfill,
+    phase,
+    cause: ['waiting', 'failed'].includes(phase) ? state.lastError : null,
+    nextRunAt: backfill.running ? state.nextRunAt : null,
+  };
 }
 
 // One run of the `history` lane. `helpers` are the lane module's failure
@@ -119,10 +148,10 @@ export async function runHistoryBackfill(ctx, { isLaneLevel, describeReadFailure
   let deleted = 0;
   let quarantined = 0;
 
-  const inBatch = async (ids) => {
+  const alreadyRead = async (ids) => {
     if (!ids.length) return new Set();
     const rows = await db.select({ key: seazonaHistoryBatchJobs.jobKey }).from(seazonaHistoryBatchJobs)
-      .where(and(eq(seazonaHistoryBatchJobs.batchId, cursor.batchId), inArray(seazonaHistoryBatchJobs.jobKey, ids.map((id) => `case:${id}`))));
+      .where(inArray(seazonaHistoryBatchJobs.jobKey, ids.map((id) => `case:${id}`)));
     return new Set(rows.map((r) => r.key.slice(5)));
   };
 
@@ -134,6 +163,7 @@ export async function runHistoryBackfill(ctx, { isLaneLevel, describeReadFailure
           break;
         }
         calls += 1;
+        cursor.listDay = cursor.nextDay;
         const list = await client.get('orders/', { ordered: orderedParam(cursor.nextDay), page: cursor.page, pageSize });
         if (!Array.isArray(list)) throw new LaneError(`Seazona order list for ${cursor.nextDay} answer was not a list`, { code: 'seazona_list_invalid' });
         // The guide says the list answers orders placed on or after `ordered`,
@@ -149,7 +179,7 @@ export async function runHistoryBackfill(ctx, { isLaneLevel, describeReadFailure
         const live = ids.length
           ? new Set((await db.select({ id: seazonaOrders.id }).from(seazonaOrders).where(inArray(seazonaOrders.id, ids))).map((r) => r.id))
           : new Set();
-        const seen = await inBatch(ids);
+        const seen = await alreadyRead(ids);
         cursor.pending = ids.filter((id) => !live.has(id) && !seen.has(id));
         if (beyond) {
           cursor.nextDay = dayOf(Date.parse(cursor.through) + DAY_MS);
@@ -163,7 +193,7 @@ export async function runHistoryBackfill(ctx, { isLaneLevel, describeReadFailure
         continue;
       }
       const id = cursor.pending.shift();
-      if ((await inBatch([id])).size) continue;
+      if ((await alreadyRead([id])).size) continue;
       calls += 1;
       try {
         const detail = await client.get(`orders/${encodeURIComponent(id)}`);

package/server/integrations/seazona/index.js

@@ -8,7 +8,7 @@ import { readBillableJobs } from './reconcile.js';
 import { SEAZONA_CALL_GUARD } from './governor.js';
 import { createSeazonaRouter } from './routes.js';
 import {
-  cancelStageMove, expiredStageMoves, handOff, readPersonSettings, requestStageMove, settleStageMoves, waitingStageMoves, writePersonSetting,
+  cancelStageMove, handOff, readPersonSettings, requestStageMove, settleStageMoves, waitingStageMoves, writePersonSetting,
 } from './stage-moves.js';
 import { orderPatient } from './patients.js';
 import { createSeazonaScheduler } from './scheduler.js';
@@ -148,17 +148,6 @@ export function createSeazonaAdapter({ env = null, fetchImpl = null, now = Date.
         if (!runtime?.client.governor) return [];
         const status = await runtime.client.governor.status();
         const alerts = guardAlerts('Seazona', status, { fix: 'Check the API client in the Seazona settings, then save them.' });
-        // Stage moves nobody made in Seazona within a day (stage-moves.js).
-        await settleStageMoves(runtime.db, { now: now() });
-        const expired = await expiredStageMoves(runtime.db, { now: now() });
-        if (expired.length) {
-          alerts.push({
-            id: 'stage-moves-expired',
-            tone: 'warn',
-            title: `${expired.length === 1 ? 'One stage move was' : `${expired.length} stage moves were`} not made in Seazona within a day: ${expired.slice(0, 5).map((m) => `${m.orderId} to ${m.toStatus}`).join(', ')}${expired.length > 5 ? ', …' : ''}. The cards went back to their Seazona stage.`,
-            members: expired.map((m) => `${m.orderId}:${m.settledAt?.toISOString() ?? ''}`),
-          });
-        }
         // Issue #143: what the lanes cannot fix by themselves. A refused API
         // client already has its own alert above, so it stops no lane here.
         if (!runtime.settings.scheduled) return alerts;

package/server/integrations/seazona/lanes.js

@@ -430,47 +430,62 @@ const laneRuns = {
 
   async orders_recent(ctx) {
     const { db, client, sync, at } = ctx;
-    const nowMs = at.getTime();
-    const lookbackStart = floorUtcDay(nowMs - sync.orderLookbackDays * DAY_MS);
-    const doneThrough = Date.parse(ctx.state?.cursor?.completedThrough ?? '');
-    const partial = ctx.state?.cursor?.partial;
-    const partialDay = Date.parse(partial?.day ?? '');
-    // Go on inside a day a run did not finish; otherwise re-read the last
-    // finished day as well, so late orders on it are seen.
-    const resumeInside = Number.isFinite(partialDay) && partialDay >= lookbackStart;
-    const resume = resumeInside ? partialDay : Number.isFinite(doneThrough) ? Math.max(lookbackStart, doneThrough) : lookbackStart;
-
-    // Issue #125: the list is paged (page, pageSize). A full page goes on to
-    // the next page; a short page, or a page past the day, ends the day. The
-    // guide says the list answers orders on or after `ordered`; a list that
-    // answers one day works the same way.
+    const today = floorUtcDay(at.getTime());
+    const lookbackStart = today - sync.orderLookbackDays * DAY_MS;
+    const cursor = ctx.state?.cursor ?? {};
+    const doneThrough = Date.parse(cursor.completedThrough ?? '');
+    const partialDay = Date.parse(cursor.partial?.day ?? '');
+    const todayPartialDay = Date.parse(cursor.todayPartial?.day ?? '');
+    let partial = partialDay >= lookbackStart && partialDay < today ? cursor.partial : null;
+    // A partial newest day becomes an older day at midnight. Keep its page
+    // unless an older partial already owns the rolling walk; that walk will
+    // revisit the former newest day on its next cycle too.
+    if (!partial && todayPartialDay >= lookbackStart && todayPartialDay < today) partial = cursor.todayPartial;
+    let resume = partial ? Date.parse(partial.day) : Number.isFinite(doneThrough) ? Math.max(lookbackStart, floorUtcDay(doneThrough) + DAY_MS) : lookbackStart;
+    if (resume >= today) resume = lookbackStart;
+
+    // Give today and the rolling previous-day walk a share of the existing
+    // budgets. With only one day or call available, alternate them instead
+    // of permanently starving either. Missing fields migrate naturally.
+    const single = sync.listPagesPerRun === 1 || sync.orderDaysPerRun === 1;
+    const readToday = !single || !cursor.historyNext;
     const pageSize = Math.min(ORDER_PAGE_MAX, sync.listCap);
     const byId = new Map();
     const days = [];
     let calls = 0;
     let lastDone = null;
-    let stoppedAt = null;
-    for (let day = floorUtcDay(resume); day <= floorUtcDay(nowMs) && days.length < sync.orderDaysPerRun && !stoppedAt; day += DAY_MS) {
+    let stoppedAt = partial;
+    let todayPartial = todayPartialDay === today ? cursor.todayPartial : partialDay === today ? cursor.partial : null;
+    async function readDay(day, progress, callLimit) {
       const label = `order list for ${formatOrderedDay(day)}`;
-      let page = resumeInside && day === floorUtcDay(resume) ? Math.max(1, Number(partial.page) || 1) : 1;
-      let previous = null;
-      for (;;) {
-        if (calls >= sync.listPagesPerRun) {
-          stoppedAt = { day, page };
-          break;
-        }
+      let page = Math.max(1, Number(progress?.page) || 1);
+      // Keep at most one page of IDs in the existing cursor, so splitting
+      // the budget never disables the guard against an API ignoring page.
+      let previous = progress?.previousIds ? new Set(progress.previousIds) : null;
+      while (calls < callLimit) {
         calls += 1;
         if (!days.includes(day)) days.push(day);
         const list = listOrFail(await client.get('orders/', { ordered: formatOrderedDay(day), page, pageSize }), label);
         const ids = list.map((item) => text(item?.id)).filter(Boolean);
-        // A Seazona that does not page answers the same rows again.
         if (previous && ids.length && ids.every((id) => previous.has(id))) throw cannotGoOn(label, sync, 'the next page answers the same orders');
         for (const item of list) if (text(item?.id)) byId.set(text(item.id), item);
-        if (list.length < pageSize || placedAfter(list[list.length - 1], day + DAY_MS)) break;
+        // The guide's on-or-after lists and single-day lists both work.
+        if (list.length < pageSize || placedAfter(list[list.length - 1], day + DAY_MS)) return null;
         previous = new Set(ids);
         page += 1;
       }
-      if (!stoppedAt) lastDone = day;
+      return { day: new Date(day).toISOString(), page, previousIds: [...previous] };
+    }
+    if (readToday) {
+      const todayCalls = single ? sync.listPagesPerRun : Math.ceil(sync.listPagesPerRun / 2);
+      todayPartial = await readDay(today, todayPartial, todayCalls);
+    }
+    if (!single || !readToday) {
+      for (let day = resume; day < today && days.length < sync.orderDaysPerRun && calls < sync.listPagesPerRun; day += DAY_MS) {
+        stoppedAt = await readDay(day, day === resume ? partial : null, sync.listPagesPerRun);
+        if (stoppedAt) break;
+        lastDone = day;
+      }
     }
     const known = await readKnown(db, 'orders', [...byId.keys()]);
     const summary = { created: 0, changed: 0, unchanged: 0 };
@@ -506,7 +521,9 @@ const laneRuns = {
       cursorTime: through === null ? ctx.state?.cursorTime ?? null : new Date(through),
       cursor: {
         ...(through === null ? {} : { completedThrough: new Date(through).toISOString() }),
-        ...(stoppedAt ? { partial: { day: new Date(stoppedAt.day).toISOString(), page: stoppedAt.page } } : {}),
+        ...(stoppedAt ? { partial: stoppedAt } : {}),
+        ...(todayPartial ? { todayPartial } : {}),
+        ...(single ? { historyNext: readToday } : {}),
       },
     };
   },

package/server/integrations/seazona/stage-moves.js

@@ -1,4 +1,4 @@
-import { and, eq, gte, inArray, lt, sql } from 'drizzle-orm';
+import { and, eq, inArray, sql } from 'drizzle-orm';
 import { FlowError } from '../../core/errors.js';
 import { orderStatusLabel } from './map.js';
 import { orderLink } from './settings.js';
@@ -9,12 +9,11 @@ import { seazonaOrders, seazonaPersonSettings, seazonaStageMoves } from './schem
 // hand-off. Flow records the move, the person makes it in Seazona, and the
 // next sync that reads the new status settles it. Until then the card shows
 // "Waiting for Seazona" in the new lane. After a day with no change the move
-// expires, the card goes back to Seazona's stage, and a quiet alert says so.
+// expires and the card goes back to Seazona's stage. No alert follows: the
+// person saw what to do in Seazona when they moved the card.
 // Every function here reads and writes Flow's database only.
 
 export const HAND_OFF_MS = 24 * 60 * 60_000;
-// How long an expired move stays in the alert.
-const EXPIRED_ALERT_MS = 7 * 24 * 60 * 60_000;
 const MAX_STATUS = 80;
 
 // Record a person's move of one order to `toStatus`, and answer the hand-off
@@ -77,15 +76,6 @@ export async function waitingStageMoves(db) {
   return new Map(rows.map((r) => [r.orderId, r]));
 }
 
-// The moves that expired in the last week, for the quiet alert.
-export async function expiredStageMoves(db, { now = Date.now() } = {}) {
-  return db.select().from(seazonaStageMoves).where(and(
-    eq(seazonaStageMoves.state, 'expired'),
-    gte(seazonaStageMoves.settledAt, new Date(Number(now) - EXPIRED_ALERT_MS)),
-    lt(seazonaStageMoves.settledAt, new Date(Number(now) + 1)),
-  ));
-}
-
 // What the board shows for a waiting move. `link` opens the order in
 // Seazona's web app (settings.js, orderLink); `exact` is false when it opens
 // only the lab's Seazona home page.

package/server/integrations/sentry/index.js

@@ -44,12 +44,12 @@ export const SENTRY_SETUP = {
     ],
   },
   fields: [
-    { name: 'SENTRY_DSN', label: 'DSN', kind: 'url', help: 'From the Sentry project\'s Client Keys. Browsers see it, so it is not a secret.' },
-    { name: 'SENTRY_ENVIRONMENT', label: 'Environment', help: 'How Sentry labels this installation, for example production. Empty: production, or workspace in a Replit workspace.' },
-    { name: 'SENTRY_CLIENT', label: 'Client', help: 'The name your support desk files this installation\'s reports under. Sent as the client tag. Empty: no client tag.' },
-    { name: 'SENTRY_FEEDBACK', label: 'Report button', kind: 'onoff', help: 'On: everyone signed in can send a report, with a screenshot, to this Sentry project.' },
-    { name: 'SENTRY_REPLAY', label: 'Replay', kind: 'onoff', help: 'On: each report and each browser error keeps up to the last minute of the page, as a replay with every word hidden.' },
-    { name: 'SENTRY_TRACES_SAMPLE_RATE', label: 'Traces', help: 'The share of clicks, page loads and requests timed, from 0 (off) to 1 (all). Empty: 0.2.' },
+    { name: 'SENTRY_DSN', label: 'DSN', kind: 'url', advanced: true, help: 'From the Sentry project\'s Client Keys. Browsers see it, so it is not a secret.' },
+    { name: 'SENTRY_ENVIRONMENT', label: 'Environment', advanced: true, help: 'How Sentry labels this installation, for example production. Empty: production, or workspace in a Replit workspace.' },
+    { name: 'SENTRY_CLIENT', label: 'Client', advanced: true, help: 'The name your support desk files this installation\'s reports under. Sent as the client tag. Empty: no client tag.' },
+    { name: 'SENTRY_FEEDBACK', label: 'Report button', kind: 'onoff', default: 'on', help: 'On: everyone signed in can send a report, with a screenshot, to this Sentry project.' },
+    { name: 'SENTRY_REPLAY', label: 'Replay', kind: 'onoff', default: 'on', help: 'On: each report and each browser error keeps up to the last minute of the page, as a replay with every word hidden.' },
+    { name: 'SENTRY_TRACES_SAMPLE_RATE', label: 'Traces', advanced: true, help: 'The share of clicks, page loads and requests timed, from 0 (off) to 1 (all). Empty: 0.2.' },
   ],
 };
 

package/server/integrations/setup.js

@@ -82,6 +82,7 @@ export function describeSetup({ adapter, row, env, secrets, entry, unreadable =
       choices: field.choices ?? null,
       suggest: field.suggest ?? null,
       default: field.default ?? null,
+      advanced: Boolean(field.advanced),
       source: fromHost ? 'host' : null,
     };
     if (field.secret) {

package/server/integrations/xero/drafts.js

@@ -68,6 +68,23 @@ function xeroDate(value) {
 
 const problem = (code, message, extra = {}) => ({ code, message, ...extra });
 
+// The few words the Invoices list shows for a refusal; the message says how
+// to fix it. Another code shows "Not sent" (sending.js).
+const SHORT = {
+  xero_same_reference_different_amount: 'Duplicate?',
+  xero_earlier_version_in_xero: 'Old version in Xero',
+  xero_earlier_version_unresolved: 'Check old version',
+  xero_tracking_missing: 'Tracking not in Xero',
+  xero_validation_failed: 'Xero refused',
+  xero_reconnect_needed: 'Reconnect Xero',
+  xero_token_failed: 'Reconnect Xero',
+  xero_unreachable: 'Xero offline',
+  xero_writes_off: 'Sending off',
+  xero_push_in_progress: 'Sending now',
+  xero_outcome_unknown: 'Not confirmed',
+};
+const shortFor = (error) => error.short ?? SHORT[error.code];
+
 // A person can always link the Flow contact to a Xero contact of another
 // name (create-contact.js, linkCustomer): no Xero call.
 function missingContact(name, { offerCreate }) {
@@ -292,7 +309,7 @@ export async function previewDrafts(db, runtime, organisationId, invoiceIds) {
     try {
       results.push(await previewOne(db, runtime, organisationId, invoiceId));
     } catch (error) {
-      results.push({ invoiceId, state: 'blocked', problems: [problem(error.code ?? 'xero_preview_failed', error.message)] });
+      results.push({ invoiceId, state: 'blocked', problems: [problem(error.code ?? 'xero_preview_failed', error.message, { short: shortFor(error) })] });
     }
   }
   return { syncedAt, warnings, invoices: results };
@@ -414,7 +431,7 @@ export async function checkDrafts(db, runtime, { organisationId, invoiceIds }) {
 }
 
 function failed(invoiceId, error, outcome = 'failed') {
-  return { invoiceId, outcome, error: { code: error.code ?? 'xero_push_failed', message: error.message, ...(error.details ? { details: error.details } : {}) } };
+  return { invoiceId, outcome, error: { code: error.code ?? 'xero_push_failed', message: error.message, ...(shortFor(error) ? { short: shortFor(error) } : {}), ...(error.details ? { details: error.details } : {}) } };
 }
 
 function summarise(results) {
@@ -489,16 +506,13 @@ async function pushOne(db, runtime, client, organisationId, invoiceId, { pushedB
   const match = await matchContactFor(db, organisationId, { contactId: invoice.contactId, name: document.contact.name });
   if (match.state !== 'matched') {
     const offerCreate = match.state === 'missing' && runtime.settings.createContacts && writesAllowed(runtime.settings);
-    throw xeroError(match.state === 'missing' ? 'xero_contact_missing' : 'xero_contact_ambiguous',
-      match.state === 'missing'
-        ? missingContact(document.contact.name, { offerCreate }).message
-        : twiceContact(document.contact.name).message,
-      { status: 409 });
+    const found = match.state === 'missing' ? missingContact(document.contact.name, { offerCreate }) : twiceContact(document.contact.name);
+    throw xeroError(found.code, found.message, { status: 409, short: found.short });
   }
   const items = await itemsByCode(db, organisationId, document.lines.map((l) => l.itemCode));
   const sendMode = await sendModeFor(db, organisationId, invoice.contactId);
   const { draft, problems } = buildDraft(document, { settings: runtime.settings, contact: match.contact, items, sendMode });
-  if (problems.length) throw xeroError(problems[0].code, problems.map((p) => p.message).join(' '), { status: 409 });
+  if (problems.length) throw xeroError(problems[0].code, problems.map((p) => p.message).join(' '), { status: 409, short: problems[0].short });
 
   // Live duplicate check: invoices in Xero with this reference, made by Flow
   // or by hand. Not needed when Flow's own copy of Xero already answered it
@@ -518,7 +532,7 @@ async function pushOne(db, runtime, client, organisationId, invoiceId, { pushedB
     });
     if (recent) {
       throw xeroError('xero_same_reference_different_amount',
-        `Possible duplicate: Xero ${recent.InvoiceNumber || 'invoice'} (${recent.Status}, ${(cents(recent.Total) / 100).toFixed(2)}) has this contact and reference "${draft.Reference}" at another amount. Nothing was sent. Check it, then send again choosing to send anyway.`,
+        `Xero ${recent.InvoiceNumber || 'invoice'} has the same client and reference at ${(cents(recent.Total) / 100).toFixed(2)}. Nothing was sent. Void the extra one in Xero or in Flow.`,
         { status: 409, details: { xero: shownXero(recent) } });
     }
   }
@@ -570,12 +584,12 @@ async function dispatch(db, client, push, document, { fresh = false } = {}) {
       invoiceId: push.invoiceId,
       version: push.version,
       outcome: 'ambiguous',
-      error: { code: 'xero_outcome_unknown', message: 'Xero did not say whether it made the draft. Send again: Flow repeats the same request within six minutes, and after that looks in Xero first, so no second invoice is made.' },
+      error: { code: 'xero_outcome_unknown', short: SHORT.xero_outcome_unknown, message: 'Xero did not say whether it made the draft. Send again: Flow repeats the same request within six minutes, and after that looks in Xero first, so no second invoice is made.' },
     };
   }
   if (!created?.InvoiceID) {
     await settle(db, push.id, { state: 'ambiguous', errorCode: 'xero_no_invoice_id', errorMessage: 'Xero answered without an invoice id.' });
-    return { invoiceId: push.invoiceId, version: push.version, outcome: 'ambiguous', error: { code: 'xero_outcome_unknown', message: 'Xero answered without an invoice id. Send again to settle it.' } };
+    return { invoiceId: push.invoiceId, version: push.version, outcome: 'ambiguous', error: { code: 'xero_outcome_unknown', short: SHORT.xero_outcome_unknown, message: 'Xero answered without an invoice id. Send again to settle it.' } };
   }
   return verify(db, client, push, draft, document, created, 'created');
 }
@@ -671,11 +685,11 @@ async function resume(db, runtime, client, push, document) {
         && differences(inv, draft, document).filter((d) => d !== 'date').length === 0);
   } catch (error) {
     if (error.code === 'xero_rate_limited' || isCallsStopped(error)) throw error;
-    return { invoiceId: push.invoiceId, version: push.version, outcome: 'ambiguous', error: { code: 'xero_outcome_unknown', message: 'Flow could not look in Xero to settle an earlier attempt. Send again later.' } };
+    return { invoiceId: push.invoiceId, version: push.version, outcome: 'ambiguous', error: { code: 'xero_outcome_unknown', short: SHORT.xero_outcome_unknown, message: 'Flow could not look in Xero to settle an earlier attempt. Send again later.' } };
   }
   if (candidates.length === 1) return verify(db, client, push, draft, document, candidates[0], 'reconciled');
   if (candidates.length > 1) {
-    return { invoiceId: push.invoiceId, version: push.version, outcome: 'ambiguous', error: { code: 'xero_outcome_unknown', message: `Xero holds ${candidates.length} drafts that match this invoice. Delete the extra ones in Xero, then send again.` } };
+    return { invoiceId: push.invoiceId, version: push.version, outcome: 'ambiguous', error: { code: 'xero_outcome_unknown', short: 'Extra Xero drafts', message: `Xero holds ${candidates.length} drafts that match this invoice. Delete the extra ones in Xero, then send again.` } };
   }
   const attempt = push.attempts + 1;
   const key = idempotencyKey(push.organisationId, push.invoiceId, push.version, attempt, push.bodyHash);

package/server/ui/app-page.js

@@ -51,7 +51,7 @@ const BODY = `<div class="fx-app">
   <div id="toasts" class="fx-toasts" aria-live="polite"></div>
 </div>`;
 
-export const APP_PATHS = ['/sign-in', '/jobs', '/invoices', '/invoices/:id', '/contacts', '/contacts/:id', '/reconcile', '/reconcile/:id', '/xero-import', '/people', '/integrations', '/integrations/:id', '/account', '/appearance', '/invoicing-settings', '/invoicing-settings/:id', '/automations', '/price-list', '/price-list/:id', '/custom-fields'];
+export const APP_PATHS = ['/sign-in', '/jobs', '/captures', '/invoices', '/invoices/:id', '/contacts', '/contacts/:id', '/reconcile', '/reconcile/:id', '/xero-import', '/people', '/integrations', '/integrations/:id', '/account', '/appearance', '/invoicing-settings', '/invoicing-settings/:id', '/automations', '/price-list', '/price-list/:id', '/custom-fields'];
 
 export function appPage({ defaultFamily }) {
   return renderPage({