@arcforgelabs/flow 2026.10.51 → 2026.10.53

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/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({

package/server/ui/app.js

@@ -10,6 +10,7 @@ import { getAppearance, onAppearanceChange, setAppearance, loadFonts } from '/as
 import { flowClerkAppearance } from '/assets/ui/clerk-appearance.js';
 import { ACCENT_PRESETS, normalizeAccent, THEME_FAMILIES, tokensFor } from '/assets/theme/themes.js';
 import { renderInvoice, renderInvoiceList } from '/assets/ui/invoicing.js';
+import { renderCaptures } from '/assets/ui/captures.js';
 import { renderContacts } from '/assets/ui/contacts.js';
 import { automationSection, renderAutomations } from '/assets/ui/automations.js';
 import { renderInvoicingSettings, sendModeSection } from '/assets/ui/invoicing-settings.js';
@@ -25,7 +26,7 @@ import { isSearchKey, openSearch } from '/assets/ui/search.js';
 import { alertStrip } from '/assets/ui/alerts.js';
 import { initialsOf, personLabel } from '/assets/ui/person.js';
 import { startTips } from '/assets/ui/tip.js';
-import { crumbs, dialog, edgeFade, fieldError, h, holdButton, linksOpenWith, listFrame, listHead, notice, pageHeader, pickOne, rowMenu, sectionTitle, settingRow, tileCard, tileSection, toast } from '/assets/ui/kit.js';
+import { crumbs, dialog, edgeFade, fieldError, h, holdButton, iconPicker, linksOpenWith, listFrame, listHead, notice, pageHeader, pickOne, rowMenu, sectionTitle, settingRow, tileCard, tileSection, toast } from '/assets/ui/kit.js';
 import { NAV_DEFAULT, NAV_LOCKED } from '/assets/ui/nav-pins.js';
 
 const $ = (id) => document.getElementById(id);
@@ -152,6 +153,7 @@ let me = null;
 // cannot be unpinned (nav-pins.js).
 const VIEWS = {
   jobs: { label: 'Jobs', icon: 'jobs', render: (main) => renderJobs(main, ui()) },
+  captures: { label: 'Capture', icon: 'camera', render: (main) => renderCaptures(main, ui()) },
   invoices: { label: 'Invoices', icon: 'invoices', render: (main, id) => (id ? renderInvoice(main, ui(), id) : renderInvoiceList(main, ui())) },
   contacts: { label: 'Contacts', icon: 'contacts', render: (main, id) => renderContacts(main, ui(), id) },
   reconcile: { label: 'Reconcile', icon: 'reconcile', render: (main, id) => renderReconcile(main, ui(), id) },
@@ -174,6 +176,7 @@ const ICON_PATHS = {
   jobs: '<rect x="3" y="4" width="5" height="16" rx="1"/><rect x="10" y="4" width="5" height="11" rx="1"/><rect x="17" y="4" width="4" height="14" rx="1"/>',
   invoices: '<path d="M6 3h9l4 4v14H6z"/><path d="M14 3v5h5M9 13h7M9 17h5"/>',
   contacts: '<rect x="3" y="4" width="18" height="16" rx="2"/><circle cx="9" cy="10" r="2"/><path d="M6 16c.4-1.6 1.5-2.4 3-2.4s2.6.8 3 2.4M14 9h5M14 13h4"/>',
+  camera: '<path d="M4 8h3l2-3h6l2 3h3v11H4z"/><circle cx="12" cy="13" r="3.5"/>',
   bolt: '<path d="M13 3L5 13h6l-1 8 8-10h-6z"/>',
   rules: '<path d="M3 6l2 2 4-4M3 16l2 2 4-4M13 6h8M13 12h8M13 18h8"/>',
   reconcile: '<path d="M4 8h13M13 4l4 4-4 4M20 16H7M11 12l-4 4 4 4"/>',
@@ -332,7 +335,7 @@ function navigate(event) {
 // The shared pieces a view module (invoicing.js) builds with. Its `go`
 // takes a path, or a link's click event.
 const ui = () => ({
-  h, flow, toast, notice, fieldError, pageHeader, listHead, listFrame, edgeFade, sectionTitle, settingRow, dialog, pickOne, me, holdButton, tileCard, tileSection, crumbs,
+  h, flow, toast, notice, fieldError, pageHeader, listHead, listFrame, edgeFade, sectionTitle, settingRow, dialog, pickOne, iconPicker, me, holdButton, tileCard, tileSection, crumbs,
   go: (target, options) => (typeof target === 'string' ? go(target, options) : navigate(target)),
 });
 
@@ -741,6 +744,9 @@ async function renderIntegration(main, id) {
   // Settings: closed on a phone, open on a wider screen, then as the person
   // leaves it while the page redraws (Connect).
   let settingsOpen = !window.matchMedia?.('(max-width: 639px)').matches;
+  // Advanced: the technical settings and the host's values. Open while the
+  // integration is off, so Connect shows every setting it needs.
+  let advancedOpen = null;
   const alerts = alertStrip(ui(), 'integrations', {
     scope: id,
     onLoad: ({ danger }) => {
@@ -753,10 +759,11 @@ async function renderIntegration(main, id) {
     shown = current;
     const inputs = new Map();
     const rows = [];
+    const advanced = [];
     for (const field of current.fields) {
       if (field.source === 'host') {
         // The host sets it: a value to read, not a box to type in.
-        rows.push(settingRow({
+        advanced.push(settingRow({
           label: field.label,
           help: 'Set by whoever hosts Flow.',
           control: field.secret ? h('span', { class: 'fx-dim' }, 'Set') : h('code', { class: 'fx-setting__value' }, field.value),
@@ -778,7 +785,7 @@ async function renderIntegration(main, id) {
       }
       inputs.set(field.name, { field, input });
       const suggestion = field.suggest === 'callback' ? `${location.origin}/api/${current.id}/oauth/callback` : null;
-      rows.push(settingRow({
+      (field.advanced ? advanced : rows).push(settingRow({
         label: field.label,
         hint: field.unreadable ? 'Stored with another key. Enter it again.' : null,
         help: field.help,
@@ -875,9 +882,12 @@ async function renderIntegration(main, id) {
             h('summary', { class: 'fx-int-section__title' }, 'Set up'),
             h('ol', { class: 'fx-steps' }, guide.steps.map((step) => h('li', {}, step))),
             guide.link ? h('a', { class: 'fx-btn fx-btn--sm', href: guide.link, target: '_blank', rel: 'noopener' }, `${current.name} site ↗`) : null) : null,
-          rows.length ? h('details', { class: 'fx-int-section fx-int-fold', open: settingsOpen, ontoggle: (event) => { settingsOpen = event.currentTarget.open; } },
+          rows.length || advanced.length ? h('details', { class: 'fx-int-section fx-int-fold', open: settingsOpen, ontoggle: (event) => { settingsOpen = event.currentTarget.open; } },
             h('summary', { class: 'fx-int-section__title' }, 'Settings'),
-            h('div', { class: 'fx-settings' }, rows),
+            rows.length ? h('div', { class: 'fx-settings' }, rows) : null,
+            advanced.length ? h('details', { class: 'fx-int-fold fx-int-fold--sub', open: advancedOpen ?? !on, ontoggle: (event) => { advancedOpen = event.currentTarget.open === !on ? null : event.currentTarget.open; } },
+              h('summary', {}, 'Advanced'),
+              h('div', { class: 'fx-settings' }, advanced)) : null,
             canChange && on && inputs.size ? h('div', { class: 'fx-row fx-row--end' }, h('button', { class: 'fx-btn', type: 'button', onclick: () => save(undefined) }, 'Save changes')) : null) : null,
         ].filter(Boolean)),
         h('aside', { class: 'fx-int-page__meta' },
@@ -980,21 +990,26 @@ function xeroImportSection(organisations) {
 }
 
 // Seazona's history read (docs/SEAZONA.md, "The API backfill"): past orders
-// from a start day, a few calls a run inside the rate limit. Start and Stop
-// call no Seazona; the background lane reads. While it runs, the row reads
-// its progress again every 30 seconds, from Flow only.
+// from a start day, a few calls a run inside the rate limit. Start, Resume
+// and Stop call no Seazona; the background lane reads, and skips orders Flow
+// read before. While it runs, the card reads its progress again every 5
+// seconds, from Flow only, and counts down to the lane's next run.
 function seazonaHistorySection() {
   const canAct = ['owner', 'admin'].includes(me?.person?.role);
   const yearAgo = new Date(Date.now() - 365 * 86_400_000).toISOString().slice(0, 10);
-  const from = h('input', { class: 'fx-input', type: 'date', 'aria-label': 'Read from', value: yearAgo, disabled: !canAct });
-  const status = h('span', {}, 'Checking…');
-  const jobs = h('span', { class: 'fx-num' }, '…');
+  const from = h('input', { class: 'fx-input fx-history__day', type: 'date', 'aria-label': 'Read from', value: yearAgo, disabled: !canAct });
+  const status = h('span', { class: 'fx-history__status' }, 'Checking…');
   const control = h('span', { class: 'fx-row' });
+  const bar = h('progress', { class: 'fx-history__bar', max: 1, value: 0, 'aria-label': 'Read so far' });
+  const barRow = settingRow({ label: 'Progress', hint: h('span', {}), control: bar, wide: true });
+  barRow.hidden = true;
   const day = (value) => new Date(`${value}T00:00:00Z`).toLocaleDateString('en-AU', { dateStyle: 'medium', timeZone: 'UTC' });
   const section = h('section', { class: 'fx-set fx-int-section fx-card', style: { padding: '8px 20px 16px' } },
     h('h2', { class: 'fx-set__title' }, 'History'),
-    settingRow({ label: 'Read from', hint: status, help: 'Reads past Seazona orders into Flow, 10 every 2 minutes. Each job waits on hold and never drafts by itself.', control }),
-    settingRow({ label: 'Jobs read', control: jobs }));
+    settingRow({ label: 'Read from', hint: status, help: 'Reads past Seazona orders into Flow, 10 every 2 minutes. Orders Flow read before are skipped. Each job waits on hold and never drafts by itself.', control }),
+    barRow);
+  let timer = null;
+  let tick = null;
   const press = async (button, path, body) => {
     button.disabled = true;
     try {
@@ -1006,7 +1021,14 @@ function seazonaHistorySection() {
     }
     load();
   };
+  const start = (label, body, primary = true) => h('button', {
+    class: `fx-btn fx-btn--sm${primary ? ' fx-btn--primary' : ''}`, type: 'button', disabled: !canAct,
+    onclick: (event) => press(event.currentTarget, '/api/seazona/history/backfill', body()),
+  }, label);
   const load = async () => {
+    clearTimeout(timer);
+    clearInterval(tick);
+    if (!section.isConnected && timer !== null) return;
     let body;
     try {
       body = await flow('/api/seazona/history');
@@ -1015,15 +1037,34 @@ function seazonaHistorySection() {
       return;
     }
     const run = body.backfill;
-    jobs.replaceChildren(String(body.history?.jobs ?? 0));
+    barRow.hidden = !run;
+    if (run) {
+      const span = Date.parse(run.through) - Date.parse(run.from) + 86_400_000;
+      const at = run.running ? run.readingDay ?? run.through : run.resumeFrom ?? run.through;
+      bar.value = run.running || run.resumeFrom ? Math.min(1, Math.max(0, (Date.parse(at) - Date.parse(run.from)) / span)) : 1;
+      barRow.querySelector('.fx-setting__hint').replaceChildren(`${day(run.from)} to ${day(run.through)}`);
+    }
     if (run?.running) {
-      status.replaceChildren(`Reading ${day(run.nextDay ?? run.from)} · ${run.ordersRead} read`);
+      const what = { waiting: 'Waiting', failed: 'Failed' }[run.phase] ?? `Reading ${day(run.readingDay ?? run.through)}`;
+      const reading = `${what} · ${run.ordersRead} read${run.waitingToRead ? ` · ${run.waitingToRead} to read` : ''}`;
+      const next = h('span', { class: 'fx-dim' });
+      const count = () => {
+        const left = Math.round((Date.parse(run.nextRunAt) - Date.now()) / 1000);
+        next.replaceChildren(left > 0 ? `· ${run.phase === 'running' ? 'next' : 'retry'} in ${Math.floor(left / 60)}:${String(left % 60).padStart(2, '0')}` : '· reading now');
+      };
+      if (run.nextRunAt && run.phase !== 'failed') { count(); tick = setInterval(count, 1000); }
+      status.replaceChildren(
+        run.phase === 'running' ? h('span', { class: 'fx-spinner fx-spinner--sm', 'aria-hidden': 'true' }) : '',
+        reading, next, run.cause ? h('span', { class: 'fx-dim' }, `· ${run.cause}`) : '');
       control.replaceChildren(h('button', { class: 'fx-btn fx-btn--sm', type: 'button', disabled: !canAct, onclick: (event) => press(event.currentTarget, '/api/seazona/history/backfill/stop') }, 'Stop'));
-      setTimeout(() => { if (section.isConnected) load(); }, 30_000);
-      return;
+    } else if (run?.resumeFrom) {
+      status.replaceChildren(`Stopped at ${day(run.resumeFrom)} · ${run.ordersRead} read`);
+      control.replaceChildren(from, start('Start', () => ({ from: from.value }), false), start('Resume', () => ({ from: run.resumeFrom, through: run.through })));
+    } else {
+      status.replaceChildren(run ? `Done · ${run.ordersRead} read` : 'Not started');
+      control.replaceChildren(from, start('Start', () => ({ from: from.value })));
     }
-    status.replaceChildren(run ? `${run.stopped ? 'Stopped' : 'Done'} · ${run.ordersRead} read from ${day(run.from)}` : 'Not started');
-    control.replaceChildren(from, h('button', { class: 'fx-btn fx-btn--sm fx-btn--primary', type: 'button', disabled: !canAct, onclick: (event) => press(event.currentTarget, '/api/seazona/history/backfill', { from: from.value }) }, 'Start'));
+    timer = setTimeout(() => { if (section.isConnected && run?.running) load(); }, 5_000);
   };
   load();
   return section;

package/server/ui/capture-fields.js

@@ -0,0 +1,17 @@
+// The job fields the photo reader asks for (server/core/reader.js) and the
+// capture screens label (server/ui/captures.js). No DOM, so both can use it.
+// `needed` fields are read again by the larger model when they are not sure.
+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 }),
+]);
+
+// Below this a needed field is read again (FLOW_READER_SURE_LINE can move
+// that line), and the screens mark a value as not sure (amber).
+export const SURE_LINE = 0.8;