@arcforgelabs/flow 2026.10.26 → 2026.10.29

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

@@ -71,6 +71,34 @@
       "when": 1792404377371,
       "tag": "0009_pipeline_matcher",
       "breakpoints": true
+    },
+    {
+      "idx": 10,
+      "version": "7",
+      "when": 1792407554981,
+      "tag": "0010_invoicing_rules",
+      "breakpoints": true
+    },
+    {
+      "idx": 11,
+      "version": "7",
+      "when": 1792411008479,
+      "tag": "0011_invoice_rules",
+      "breakpoints": true
+    },
+    {
+      "idx": 12,
+      "version": "7",
+      "when": 1792414436676,
+      "tag": "0012_invoice_sending",
+      "breakpoints": true
+    },
+    {
+      "idx": 13,
+      "version": "7",
+      "when": 1792414148360,
+      "tag": "0013_line_mappings",
+      "breakpoints": true
     }
   ]
 }

package/server/db/schema.js

@@ -59,6 +59,9 @@ export const priceItems = pgTable('price_items', {
   organisationId: organisationId().references(() => organisations.id),
   code: text('code').notNull(),
   name: text('name').notNull(),
+  // The accounting system's longer text for the item, when it has one. Line
+  // mapping (server/core/line-mapping.js) compares a work line with it too.
+  description: text('description'),
   unitAmountCents: integer('unit_amount_cents').notNull(),
   taxCode: text('tax_code').notNull().default('GST'),
   archivedAt: timestamp('archived_at', { withTimezone: true }),
@@ -85,6 +88,16 @@ export const invoices = pgTable('invoices', {
   subtotalCents: integer('subtotal_cents').notNull().default(0),
   taxCents: integer('tax_cents').notNull().default(0),
   totalCents: integer('total_cents').notNull().default(0),
+  // When a person marked the draft ready to send, and who. Any change to the
+  // draft clears it (server/core/sending.js).
+  readyAt: timestamp('ready_at', { withTimezone: true }),
+  readyBy: uuid('ready_by').references(() => people.id, { onDelete: 'set null' }),
+  // Sending to the accounting system (server/core/sending.js): queued by a
+  // person, then sent or failed. `sendError` is { code, message } while failed.
+  sendState: text('send_state'),
+  sendError: jsonb('send_error'),
+  sendRequestedBy: uuid('send_requested_by').references(() => people.id, { onDelete: 'set null' }),
+  sendUpdatedAt: timestamp('send_updated_at', { withTimezone: true }),
   createdAt: createdAt(),
   updatedAt: updatedAt(),
 }, (t) => [
@@ -97,6 +110,7 @@ export const invoices = pgTable('invoices', {
   }),
   check('invoices_status_valid', sql`${t.status} in ('draft', 'issued', 'void')`),
   check('invoices_issued_has_number', sql`${t.status} = 'draft' or ${t.number} is not null`),
+  check('invoices_send_state_valid', sql`${t.sendState} is null or ${t.sendState} in ('queued', 'sent', 'failed')`),
 ]);
 
 export const invoiceLines = pgTable('invoice_lines', {
@@ -109,6 +123,9 @@ export const invoiceLines = pgTable('invoice_lines', {
   quantity: integer('quantity').notNull(),
   unitAmountCents: integer('unit_amount_cents').notNull(),
   taxCode: text('tax_code').notNull(),
+  // A line with no price item may name the accounting account it books to,
+  // for example a surcharge (server/core/line-mapping.js).
+  accountCode: text('account_code'),
   lineAmountCents: integer('line_amount_cents').notNull(),
   taxCents: integer('tax_cents').notNull(),
 }, (t) => [
@@ -209,6 +226,13 @@ export const billingObligations = pgTable('billing_obligations', {
   // The day of the work, for matching it to an accounting invoice: the work
   // system's invoice date, else its due date, else its order date.
   jobDate: date('job_date'),
+  // The work system's status for the job, as it reported it (for example
+  // "Shipped"). The draft rules read it.
+  sourceStatus: text('source_status'),
+  // Flow's own stage: the job is ready to invoice, since when and by whom (a
+  // person, or an automation such as one that reads the work system status).
+  readyAt: timestamp('ready_at', { withTimezone: true }),
+  readyBy: text('ready_by'),
   // The lines as the work system reported them, normalised.
   lines: jsonb('lines').notNull().default(sql`'[]'::jsonb`),
   lineFingerprint: text('line_fingerprint').notNull(),
@@ -559,3 +583,137 @@ export const linkRejections = pgTable('link_rejections', {
     foreignColumns: [billingObligations.organisationId, billingObligations.id],
   }),
 ]);
+
+// Invoicing rules (server/core/invoicing-rules.js). One row for each
+// organisation: the checks a job passes before Flow drafts its invoice, and
+// how a checked draft goes to the accounting system. No row means the
+// defaults. When Flow drafts is an automation (`automations`).
+export const SEND_MODES = ['accounting_draft', 'approve_and_email'];
+
+export const invoicingSettings = pgTable('invoicing_settings', {
+  organisationId: uuid('organisation_id').primaryKey().references(() => organisations.id),
+  // accounting_draft: a person checks the draft in Flow, Flow sends it as an
+  // accounting draft, and a person approves and sends it there.
+  // approve_and_email: a person approves the draft in Flow, Flow sends it
+  // approved, and the accounting system emails it to the customer.
+  sendMode: text('send_mode').notNull().default('accounting_draft'),
+  // A job whose date is more than this many days ago waits for a person.
+  staleDays: integer('stale_days').notNull().default(90),
+  // The days from the invoice date to its due date.
+  paymentTermsDays: integer('payment_terms_days').notNull().default(30),
+  // A job needs a practitioner, its own or its customer's default one.
+  requirePractitioner: boolean('require_practitioner').notNull().default(false),
+  // The price item code of a rush charge, and its share of the other lines.
+  rushItemCode: text('rush_item_code'),
+  rushPercent: integer('rush_percent').notNull().default(20),
+  // The fixed checks above became invoice rules (invoice_rules). True once
+  // this organisation's starter rules were made from them.
+  rulesSeeded: boolean('rules_seeded').notNull().default(false),
+  updatedBy: uuid('updated_by').references(() => people.id, { onDelete: 'set null' }),
+  updatedAt: updatedAt(),
+}, (t) => [
+  check('invoicing_settings_send_mode_valid', inList('send_mode', SEND_MODES)),
+  check('invoicing_settings_stale_days_valid', sql`${t.staleDays} between 1 and 3650`),
+  check('invoicing_settings_terms_valid', sql`${t.paymentTermsDays} between 0 and 365`),
+  check('invoicing_settings_rush_valid', sql`${t.rushPercent} between 0 and 100`),
+]);
+
+// One customer's own invoicing settings. A null value takes the
+// organisation's setting.
+export const customerBillingSettings = pgTable('customer_billing_settings', {
+  organisationId: organisationId().references(() => organisations.id),
+  contactId: uuid('contact_id').notNull(),
+  // A customer that is not billable never gets an invoice from a rule, and
+  // `autoDraft` false keeps the draft automation off for this customer.
+  billable: boolean('billable').notNull().default(true),
+  defaultPractitioner: text('default_practitioner'),
+  autoDraft: boolean('auto_draft'),
+  sendMode: text('send_mode'),
+  paymentTermsDays: integer('payment_terms_days'),
+  updatedBy: uuid('updated_by').references(() => people.id, { onDelete: 'set null' }),
+  updatedAt: updatedAt(),
+}, (t) => [
+  primaryKey({ name: 'customer_billing_settings_pk', columns: [t.organisationId, t.contactId] }),
+  foreignKey({
+    name: 'customer_billing_settings_contact_same_org',
+    columns: [t.organisationId, t.contactId],
+    foreignColumns: [contacts.organisationId, contacts.id],
+  }),
+  check('customer_billing_settings_send_mode_valid', sql`${t.sendMode} is null or ${t.sendMode} in ('accounting_draft', 'approve_and_email')`),
+  check('customer_billing_settings_terms_valid', sql`${t.paymentTermsDays} is null or ${t.paymentTermsDays} between 0 and 365`),
+]);
+
+// Invoice rules (server/core/invoice-rules.js, docs/INVOICE_RULES.md): a lab's
+// own checks on a job before Flow drafts its invoice. Each rule is When, If and
+// Then: `conditions` is a list of { field, test, value, item? } that must all
+// match, and `action` is { kind: 'wait' | 'skip' }. `starter_key` marks a rule
+// Flow made from the earlier fixed settings, once per organisation.
+export const invoiceRules = pgTable('invoice_rules', {
+  id: id(),
+  organisationId: organisationId().references(() => organisations.id),
+  name: text('name').notNull(),
+  position: integer('position').notNull(),
+  enabled: boolean('enabled').notNull().default(true),
+  trigger: text('trigger').notNull().default('job_ready'),
+  conditions: jsonb('conditions').notNull().default(sql`'[]'::jsonb`),
+  action: jsonb('action').notNull(),
+  starterKey: text('starter_key'),
+  updatedBy: uuid('updated_by').references(() => people.id, { onDelete: 'set null' }),
+  createdAt: createdAt(),
+  updatedAt: updatedAt(),
+}, (t) => [
+  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`),
+]);
+
+// Automations (server/core/automations.js): Flow's routines, each on or off,
+// with its own settings. The routines are defined in code; a row holds an
+// organisation's choice. No row means the routine's default.
+export const automations = pgTable('automations', {
+  organisationId: organisationId().references(() => organisations.id),
+  key: text('key').notNull(),
+  enabled: boolean('enabled').notNull(),
+  config: jsonb('config').notNull().default(sql`'{}'::jsonb`),
+  updatedBy: uuid('updated_by').references(() => people.id, { onDelete: 'set null' }),
+  updatedAt: updatedAt(),
+}, (t) => [
+  primaryKey({ name: 'automations_pk', columns: [t.organisationId, t.key] }),
+]);
+
+// Line mappings (docs/LINE_MAPPING.md): how a work system's line label finds
+// the lab's price item, as rows the lab edits. `kind` says which step of the
+// line mapping routine uses the row:
+//   alias        label (exact, or the start of it) -> price item code
+//   price_alias  label and unit price -> price item code
+//   saved        label and unit price -> price item code, chosen by a person
+//   account      label -> a line with no price item, booked to an account
+// `label` is stored in the lookup form (lineLookupText), so it matches in any
+// case, spacing or punctuation.
+export const LINE_MAPPING_KINDS = ['alias', 'price_alias', 'saved', 'account'];
+export const lineMappings = pgTable('line_mappings', {
+  id: id(),
+  organisationId: organisationId().references(() => organisations.id),
+  kind: text('kind').notNull(),
+  match: text('match').notNull().default('exact'),
+  label: text('label').notNull(),
+  unitAmountCents: integer('unit_amount_cents'),
+  itemCode: text('item_code'),
+  accountCode: text('account_code'),
+  taxCode: text('tax_code'),
+  description: text('description'),
+  enabled: boolean('enabled').notNull().default(true),
+  // Who made it: a person, a setup profile, or the earlier codebase's rules.
+  origin: text('origin').notNull().default('person'),
+  updatedBy: uuid('updated_by').references(() => people.id, { onDelete: 'set null' }),
+  createdAt: createdAt(),
+  updatedAt: updatedAt(),
+}, (t) => [
+  uniqueIndex('line_mappings_unique').on(t.organisationId, t.kind, t.match, t.label, sql`coalesce(${t.unitAmountCents}, -1)`),
+  check('line_mappings_kind_valid', sql`${t.kind} in ('alias', 'price_alias', 'saved', 'account')`),
+  check('line_mappings_match_valid', sql`${t.match} in ('exact', 'starts_with')`),
+  check('line_mappings_tax_code_valid', sql`${t.taxCode} is null or ${t.taxCode} in ('GST', 'GST_FREE')`),
+  check('line_mappings_target', sql`(${t.kind} = 'account' and ${t.accountCode} is not null) or (${t.kind} <> 'account' and ${t.itemCode} is not null)`),
+  check('line_mappings_price', sql`${t.kind} not in ('price_alias', 'saved') or ${t.unitAmountCents} is not null`),
+  check('line_mappings_label_valid', sql`length(${t.label}) between 1 and 200`),
+]);

package/server/import/at-start.js

@@ -1,5 +1,6 @@
-import { sql } from 'drizzle-orm';
-import { organisations, priorLinks } from '../db/schema.js';
+import { and, eq, isNull, sql } from 'drizzle-orm';
+import { lineMappings, organisations, priceItems, priorLinks } from '../db/schema.js';
+import { lineLookupText, remapJobs } from '../core/line-mapping.js';
 import { applyImport, planImport, readEarlierFlow, summarisePlan } from './earlier-flow.js';
 
 // The import from the earlier codebase, run once by the server itself. On a
@@ -118,3 +119,64 @@ export async function importEarlierLinksAtStart({ db, pool, settings, log = cons
   log.info?.(`[import] links from schema "${settings.schema}": ${JSON.stringify(counts)}`);
   return counts;
 }
+
+// Carries the earlier app's line mapping knowledge into Flow, at every start
+// while the import settings are set, in the same read-only way:
+// - each label and price a person matched to an item becomes a "saved" line
+//   mapping (server/core/line-mapping.js), unless the lab already has one;
+// - each price item with no description takes the accounting item's own.
+// Answers counts, or null when there is nothing to read.
+const EARLIER_RULES = 'xero_item_match_rules';
+const EARLIER_ITEMS = 'xero_catalog_items';
+
+export async function importEarlierMappingsAtStart({ db, pool, settings, log = console }) {
+  if (!settings) return null;
+  const { rows: labs } = await db.execute(sql`select id, name from ${organisations}`);
+  const organisation = labs.find((lab) => lab.name === settings.organisationName) ?? (labs.length === 1 ? labs[0] : null);
+  if (!organisation) return null;
+
+  let rules = [];
+  let items = [];
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN TRANSACTION READ ONLY');
+    await client.query(`SET LOCAL search_path TO "${settings.schema}"`);
+    const present = async (table) => (await client.query('select to_regclass($1) is not null as present', [table])).rows[0].present;
+    if (await present(EARLIER_RULES)) {
+      ({ rows: rules } = await client.query(`select source_lookup_text, unit_amount_cents, xero_item_code from ${EARLIER_RULES}`));
+    }
+    if (await present(EARLIER_ITEMS)) {
+      ({ rows: items } = await client.query(`select item_code, description from ${EARLIER_ITEMS} where coalesce(description, '') <> ''`));
+    }
+    await client.query('COMMIT');
+  } catch (error) {
+    await client.query('ROLLBACK').catch(() => {});
+    throw new Error(`could not read mappings from schema "${settings.schema}": ${error.message}`);
+  } finally {
+    client.release();
+  }
+
+  const values = rules
+    .map((row) => ({
+      organisationId: organisation.id,
+      kind: 'saved',
+      match: 'exact',
+      label: lineLookupText(row.source_lookup_text),
+      unitAmountCents: Number(row.unit_amount_cents),
+      itemCode: String(row.xero_item_code ?? '').trim(),
+      origin: `earlier:${EARLIER_RULES}`,
+    }))
+    .filter((v) => v.label && v.label.length <= 200 && v.itemCode && Number.isInteger(v.unitAmountCents) && v.unitAmountCents >= 0);
+  const added = values.length ? (await db.insert(lineMappings).values(values).onConflictDoNothing().returning({ id: lineMappings.id })).length : 0;
+  let described = 0;
+  for (const item of items) {
+    const updated = await db.update(priceItems).set({ description: String(item.description).trim().slice(0, 1000) })
+      .where(and(eq(priceItems.organisationId, organisation.id), eq(priceItems.code, String(item.item_code).trim()), isNull(priceItems.description)))
+      .returning({ id: priceItems.id });
+    described += updated.length;
+  }
+  if (added) await remapJobs(db, organisation.id);
+  const counts = { rules: values.length, added, described };
+  log.info?.(`[import] mappings from schema "${settings.schema}": ${JSON.stringify(counts)}`);
+  return counts;
+}

package/server/index.js

@@ -5,8 +5,12 @@ import { seedFirstOwner } from './auth/people.js';
 import { createPersonAuth } from './auth/session.js';
 import { resolveSignInSettings } from './auth/settings.js';
 import { migrateDatabase, openDatabase } from './db/index.js';
-import { importEarlierAtStart, importEarlierLinksAtStart, resolveImportAtStart } from './import/at-start.js';
+import {
+  importEarlierAtStart, importEarlierLinksAtStart, importEarlierMappingsAtStart, resolveImportAtStart,
+} from './import/at-start.js';
+import { createMonitoredLog } from './core/monitoring.js';
 import { createPipelineWorker } from './core/pipeline.js';
+import { createSendWorker } from './core/sending.js';
 import { resolveSecretsKey } from './core/secrets.js';
 import { adapters as shippedAdapters } from './integrations/adapters.js';
 import { createIntegrations, resolveEnabledIntegrations } from './integrations/index.js';
@@ -64,14 +68,19 @@ try {
 // failure is logged and the start goes on.
 await importEarlierLinksAtStart({ db: database.db, pool: database.pool, settings: importAtStart })
   .catch((error) => console.error(`[import] ${error.message}`));
+await importEarlierMappingsAtStart({ db: database.db, pool: database.pool, settings: importAtStart })
+  .catch((error) => console.error(`[import] ${error.message}`));
 // What an owner set in Settings, Integrations, with the host's own
 // environment over it (server/integrations/setup.js).
+// Every part of Flow logs here: each error also goes to the installation's
+// own error service while one is on (docs/SENTRY.md).
 let integrations;
+const log = createMonitoredLog({ log: console, reporters: () => integrations?.with('captureError') ?? [] });
 try {
   const stored = await readStoredSettings(database.db);
   const { env: settingsEnv, unreadable } = settingsEnvironment({ env: process.env, stored, adapters: shippedAdapters, secrets });
   if (unreadable.length) console.warn(`[integrations] stored credentials Flow cannot read with this secrets key: ${unreadable.join(', ')}. An owner enters them again in Settings.`);
-  integrations = createIntegrations({ turnedOnInFlow: storedEnabled(stored, process.env), settingsEnv });
+  integrations = createIntegrations({ turnedOnInFlow: storedEnabled(stored, process.env), settingsEnv, log });
   await integrations.start(database.db);
 } catch (error) {
   console.error(`[integrations] ${error.message}`);
@@ -85,14 +94,17 @@ console.log(`[integrations] on: ${integrationsOn.join(', ') || 'none'}; secrets
 // only while an integration that feeds it is on, and writes to no other
 // system. FLOW_PIPELINE=off stops it.
 if (process.env.FLOW_PIPELINE !== 'off') {
-  createPipelineWorker({ db: database.db, integrations }).start();
+  createPipelineWorker({ db: database.db, integrations, log }).start();
 }
+// The send worker (server/core/sending.js) sends only what a person queued
+// with Send all ready, to the accounting integration that is on.
+createSendWorker({ db: database.db, integrations, log }).start();
 
 let auth = null;
 if (settings.mode === 'clerk') {
   const { keys } = settings;
   const clerk = await loadClerkAdapter({ ...keys, authorizedParties: settings.authorizedParties });
-  const personAuth = createPersonAuth({ db: database.db, clerk, ...settings });
+  const personAuth = createPersonAuth({ db: database.db, clerk, ...settings, log });
   let clerkProxy = null;
   const proxyPath = resolveClerkProxyPath(keys.proxyUrl);
   if (proxyPath) {
@@ -129,7 +141,7 @@ const trustProxy = process.env.REPL_ID || process.env.REPLIT_DEPLOYMENT ? 1 : fa
 
 const updates = createUpdateChecker();
 
-createApp({ database, auth, trustProxy, updates, integrations, secrets, defaultFamily }).listen(port, () => {
+createApp({ database, auth, trustProxy, updates, integrations, secrets, defaultFamily, log }).listen(port, () => {
   console.log(`[flow] listening on ${port}; design system ${defaultFamily} (FLOW_THEME)`);
 });
 

package/server/integrations/adapters.js

@@ -1,6 +1,7 @@
 // The adapters this build of Flow ships. server/index.js registers each one;
 // FLOW_INTEGRATIONS chooses which are on (server/integrations/index.js).
 import { seazonaAdapter } from './seazona/index.js';
+import { sentryAdapter } from './sentry/index.js';
 import { xeroAdapter } from './xero/index.js';
 
-export const adapters = [seazonaAdapter, xeroAdapter];
+export const adapters = [seazonaAdapter, sentryAdapter, xeroAdapter];

package/server/integrations/port.js

@@ -12,12 +12,18 @@ import { isMissingTable, migrateAdapterSchema } from './schema.js';
 export const CAPABILITIES = Object.freeze([
   'pullWorkItems', // billable work since a cursor (Seazona: completed cases)
   'pushInvoice', // send an issued invoice; the Flow record id is the idempotency key
+  'pushInvoices', // send several issued invoices in one pass (Send all ready, server/core/sending.js)
+  'checkDrafts', // the accounting system's problems with Flow drafts, from its copy; null while not connected
+  'sendStatus', // { connected, writesAllowed }: may Flow send invoices now?
   'pushBill', // send an approved bill; the Flow record id is the idempotency key
   'pullPayments', // payments since a cursor, matched to invoices and bills
   'checkInvoice', // does the accounting system hold an invoice for a billable job? (the ledger's liveCheck)
+  'listWork', // the work system's jobs from its copy in Flow, open and lately finished, for the Jobs board
   'listCustomers', // the system's customers, by id and name, for the identity map (Seazona: clients; Xero: contacts)
   'findInvoices', // sales invoices in the accounting system's copy, for the matcher; never a live call
   'health', // connection state for Settings
+  'captureError', // an error Flow logged, sent to the installation's own error service (Sentry)
+  'browserMonitoring', // the public settings a browser needs to report errors and problems to that service
 ]);
 
 const ID_PATTERN = /^[a-z][a-z0-9-]{1,31}$/;

package/server/integrations/seazona/feed.js

@@ -1,6 +1,6 @@
-import { eq, sql } from 'drizzle-orm';
+import { and, desc, eq, gte, isNull, or, sql } from 'drizzle-orm';
 import { ledgerLinesFor, toLedgerHold, toLedgerJob } from './ledger.js';
-import { orderStatusLabel, parseSeazonaDate } from './map.js';
+import { isFinalStatus, orderStatusLabel, parseSeazonaDate } from './map.js';
 import { seazonaClients, seazonaInvoices, seazonaOrders } from './schema.js';
 
 // The billing feed behind the port's pullWorkItems: every order that changed
@@ -104,12 +104,70 @@ export async function readBillableWork(db, { cursor = null, limit = 200 } = {})
 }
 
 // Seazona clients, by id and the company name an invoice bills. A client
-// with no company name is listed by its full name.
+// with no company name is listed by its full name. A client the client list
+// never gave (the list can be closed to an API client) is listed by the
+// company name its orders carry, so its jobs still find their customer.
 export async function listClients(db) {
   const rows = await db.select({ id: seazonaClients.id, company: seazonaClients.company, fullName: seazonaClients.fullName, active: seazonaClients.active })
     .from(seazonaClients);
-  return rows
+  const listed = rows
     .filter((r) => r.active !== false)
     .map((r) => ({ id: r.id, name: (r.company || r.fullName || '').trim() }))
     .filter((r) => r.name);
+  const known = new Set(rows.map((r) => r.id));
+  const fromOrders = await db.selectDistinctOn([seazonaOrders.clientId], { id: seazonaOrders.clientId, company: seazonaOrders.company })
+    .from(seazonaOrders)
+    .where(sql`${seazonaOrders.clientId} is not null and coalesce(${seazonaOrders.company}, '') <> '' and ${seazonaOrders.deletedInSourceAt} is null`)
+    .orderBy(seazonaOrders.clientId, sql`${seazonaOrders.lastChangedAt} desc`);
+  return [
+    ...listed,
+    ...fromOrders.filter((r) => !known.has(r.id)).map((r) => ({ id: r.id, name: r.company.trim() })),
+  ];
+}
+
+// A final order (shipped, delivered, cancelled; map.js isFinalStatus) stays on
+// the Jobs board this long after it last changed.
+export const WORK_FINISHED_DAYS = 30;
+const WORK_LIMIT = 2000;
+const FINAL_SQL = sql`coalesce(${seazonaOrders.status}, '') ~* '(shipped|delivered|cancelled|canceled|void|closed|archived|deleted)'`;
+
+// The orders behind the port's listWork, for the Jobs board: every open
+// order, and each final order that changed in the last WORK_FINISHED_DAYS
+// days, newest change first. An order deleted in Seazona is never listed.
+// The client name is the Seazona client's company (or full name), else the
+// order's own company. `statuses` lists each status once, with the first time
+// Flow saw an order in it, so the board can order its columns.
+export async function listWork(db, { now = Date.now(), finishedDays = WORK_FINISHED_DAYS, limit = WORK_LIMIT } = {}) {
+  const since = new Date(now - finishedDays * 86_400_000);
+  const rows = await db.select({ order: seazonaOrders, company: seazonaClients.company, fullName: seazonaClients.fullName })
+    .from(seazonaOrders)
+    .leftJoin(seazonaClients, eq(seazonaClients.id, seazonaOrders.clientId))
+    .where(and(isNull(seazonaOrders.deletedInSourceAt), or(sql`not (${FINAL_SQL})`, gte(seazonaOrders.lastChangedAt, since))))
+    .orderBy(desc(seazonaOrders.lastChangedAt), seazonaOrders.id)
+    .limit(limit);
+  const firstSeen = new Map();
+  const items = rows.map(({ order, company, fullName }) => {
+    const status = orderStatusLabel(order) || null;
+    const seen = firstSeen.get(status);
+    if (status && (!seen || order.firstSeenAt < seen)) firstSeen.set(status, order.firstSeenAt);
+    return {
+      sourceSystem: 'seazona',
+      sourceJobRef: order.id,
+      // The Seazona order id is the case number. Never patient data.
+      caseRef: order.id,
+      status,
+      clientId: order.clientId,
+      clientName: (company || order.company || fullName || '').trim() || null,
+      practitioner: order.doctorName,
+      department: order.department,
+      orderedOn: parseSeazonaDate(order.orderedText),
+      dueOn: parseSeazonaDate(order.dueText),
+      lines: (order.lines ?? []).map((l) => ({ code: l.code ?? null, description: l.description, amountCents: l.amountCents ?? null })),
+      totalCents: order.subtotalCents,
+    };
+  });
+  return {
+    items,
+    statuses: [...firstSeen].map(([label, at]) => ({ label, final: isFinalStatus(label), firstSeenAt: at.toISOString() })),
+  };
 }

package/server/integrations/seazona/index.js

@@ -1,5 +1,5 @@
 import { createSeazonaClient } from './client.js';
-import { listClients, readBillableWork } from './feed.js';
+import { listClients, listWork, readBillableWork } from './feed.js';
 import { readSeazonaSyncHealth, runSeazonaSync } from './lanes.js';
 import { createSeazonaScheduler } from './scheduler.js';
 import { describeSeazonaSettings, resolveSeazonaSettings } from './settings.js';
@@ -105,6 +105,12 @@ export function createSeazonaAdapter({ env = null, fetchImpl = null, now = Date.
       async listCustomers() {
         return listClients(current().db);
       },
+
+      // Open orders and orders finished lately, with their statuses, for the
+      // Jobs board. Reads Flow's copy only.
+      async listWork() {
+        return listWork(current().db, { now: now() });
+      },
     },
   };
 }

package/server/integrations/seazona/lanes.js

@@ -309,8 +309,11 @@ const laneRuns = {
   async clients(ctx) {
     const { client, sync, at } = ctx;
     // The first run reads the whole list; later runs read changes only.
+    // Seazona answers the whole list only to an empty `?lastModified=`; a
+    // bare path is a 404.
     const since = ctx.state?.cursorTime ? cursorSince(ctx, 0) : '';
-    const items = listOrFail(await client.get('clients/', since ? { lastModified: since } : {}), 'client list', sync);
+    const reply = since ? await client.get('clients/', { lastModified: since }) : await client.get('clients/?lastModified=');
+    const items = listOrFail(reply, 'client list', sync);
     const result = await syncListWithDetail(ctx, {
       mirror: 'clients',
       what: 'client',

package/server/integrations/seazona/ledger.js

@@ -48,6 +48,8 @@ export function toLedgerJob(item) {
     shippedOn: null,
     // The day of the work, for matching it to its accounting invoice.
     jobDate: item.invoice?.invoiceDate ?? item.dueOn ?? item.orderedOn ?? null,
+    // The draft rules bill only the statuses the lab chose (for example Shipped).
+    sourceStatus: item.status ?? null,
     lines: ledgerLinesFor(item).lines,
     observedAt: item.syncedAt,
     actor: SEAZONA_SOURCE_SYSTEM,

package/server/integrations/seazona/migrations/0000_api_governor.sql

@@ -1,11 +1,11 @@
-CREATE TABLE "seazona_api_governor" (
+CREATE TABLE IF NOT EXISTS "seazona_api_governor" (
 	"client_key" text PRIMARY KEY NOT NULL,
 	"next_eligible_at" timestamp with time zone DEFAULT 'epoch' NOT NULL,
 	"cooldown_until" timestamp with time zone DEFAULT 'epoch' NOT NULL,
 	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
 );
 --> statement-breakpoint
-CREATE TABLE "seazona_api_requests" (
+CREATE TABLE IF NOT EXISTS "seazona_api_requests" (
 	"id" bigserial PRIMARY KEY NOT NULL,
 	"client_key" text NOT NULL,
 	"workflow" text NOT NULL,
@@ -17,4 +17,4 @@ CREATE TABLE "seazona_api_requests" (
 	"is_retry" boolean DEFAULT false NOT NULL
 );
 --> statement-breakpoint
-CREATE INDEX "seazona_api_requests_window" ON "seazona_api_requests" USING btree ("client_key","admitted_at");
+CREATE INDEX IF NOT EXISTS "seazona_api_requests_window" ON "seazona_api_requests" USING btree ("client_key","admitted_at");

package/server/integrations/seazona/migrations/0001_mirror.sql

@@ -1,4 +1,4 @@
-CREATE TABLE "seazona_clients" (
+CREATE TABLE IF NOT EXISTS "seazona_clients" (
 	"id" text PRIMARY KEY NOT NULL,
 	"account_number" text,
 	"company" text,
@@ -17,7 +17,7 @@ CREATE TABLE "seazona_clients" (
 	"last_changed_at" timestamp with time zone NOT NULL
 );
 --> statement-breakpoint
-CREATE TABLE "seazona_invoices" (
+CREATE TABLE IF NOT EXISTS "seazona_invoices" (
 	"invoice_number" text PRIMARY KEY NOT NULL,
 	"seazona_id" text,
 	"client_id" text,
@@ -41,7 +41,7 @@ CREATE TABLE "seazona_invoices" (
 	"last_changed_at" timestamp with time zone NOT NULL
 );
 --> statement-breakpoint
-CREATE TABLE "seazona_lane_state" (
+CREATE TABLE IF NOT EXISTS "seazona_lane_state" (
 	"lane" text PRIMARY KEY NOT NULL,
 	"status" text DEFAULT 'idle' NOT NULL,
 	"cursor_time" timestamp with time zone,
@@ -56,7 +56,7 @@ CREATE TABLE "seazona_lane_state" (
 	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
 );
 --> statement-breakpoint
-CREATE TABLE "seazona_order_read_failures" (
+CREATE TABLE IF NOT EXISTS "seazona_order_read_failures" (
 	"order_id" text PRIMARY KEY NOT NULL,
 	"failure_count" integer NOT NULL,
 	"last_attempt_at" timestamp with time zone NOT NULL,
@@ -66,7 +66,7 @@ CREATE TABLE "seazona_order_read_failures" (
 	"quarantined_until" timestamp with time zone
 );
 --> statement-breakpoint
-CREATE TABLE "seazona_orders" (
+CREATE TABLE IF NOT EXISTS "seazona_orders" (
 	"id" text PRIMARY KEY NOT NULL,
 	"invoice_number" text,
 	"client_id" text,
@@ -88,7 +88,7 @@ CREATE TABLE "seazona_orders" (
 	"last_changed_at" timestamp with time zone NOT NULL
 );
 --> statement-breakpoint
-CREATE TABLE "seazona_reference" (
+CREATE TABLE IF NOT EXISTS "seazona_reference" (
 	"resource" text NOT NULL,
 	"id" text NOT NULL,
 	"name" text,
@@ -101,6 +101,6 @@ CREATE TABLE "seazona_reference" (
 	CONSTRAINT "seazona_reference_resource_id_pk" PRIMARY KEY("resource","id")
 );
 --> statement-breakpoint
-CREATE INDEX "seazona_invoices_changed" ON "seazona_invoices" USING btree ("last_changed_at");--> statement-breakpoint
-CREATE INDEX "seazona_orders_invoice_number" ON "seazona_orders" USING btree ("invoice_number");--> statement-breakpoint
-CREATE INDEX "seazona_orders_changed" ON "seazona_orders" USING btree ("last_changed_at");
+CREATE INDEX IF NOT EXISTS "seazona_invoices_changed" ON "seazona_invoices" USING btree ("last_changed_at");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "seazona_orders_invoice_number" ON "seazona_orders" USING btree ("invoice_number");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "seazona_orders_changed" ON "seazona_orders" USING btree ("last_changed_at");