@arcforgelabs/flow 2026.10.27 → 2026.10.29

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

@@ -92,6 +92,13 @@
       "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 }),
@@ -120,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) => [
@@ -674,3 +680,40 @@ export const automations = pgTable('automations', {
 }, (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,7 +5,9 @@ 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';
@@ -66,6 +68,8 @@ 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

package/server/integrations/port.js

@@ -18,6 +18,7 @@ export const CAPABILITIES = Object.freeze([
   '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

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/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");

package/server/integrations/xero/drafts.js

@@ -94,7 +94,7 @@ async function documentFor(db, organisationId, invoiceId) {
       currency: invoice.currency,
       contact: { id: contact.id, name: contact.name, email: contact.email },
       lines: invoice.lines.map((l) => ({
-        position: l.position, itemCode: codes.get(l.priceItemId) ?? null, description: l.description, quantity: l.quantity,
+        position: l.position, itemCode: codes.get(l.priceItemId) ?? null, ...(l.accountCode ? { accountCode: l.accountCode } : {}), description: l.description, quantity: l.quantity,
         unitAmountCents: l.unitAmountCents, taxCode: l.taxCode, lineAmountCents: l.lineAmountCents, taxCents: l.taxCents,
       })),
       subtotalCents: invoice.subtotalCents,
@@ -131,6 +131,9 @@ export function buildDraft(document, { settings, contact, items, sendMode = 'acc
     if (line.itemCode) {
       if (items.has(line.itemCode)) out.ItemCode = line.itemCode;
       else problems.push(problem('xero_item_missing', `Line ${line.position}: item ${line.itemCode} is not in Xero. Add it in Xero, then sync.`, { itemCode: line.itemCode }));
+    } else if (line.accountCode) {
+      // A line with no item books to its own account, such as a surcharge.
+      out.AccountCode = line.accountCode;
     }
     if (tracking) out.Tracking = [tracking];
     return out;

package/server/integrations/xero/lookup.js

@@ -1,6 +1,5 @@
 import { sql } from 'drizzle-orm';
 import { ledgerState } from './ledger.js';
-import { MIRROR_RESOURCES } from './mirror.js';
 
 // What the core's matcher (server/core/pipeline.js) reads from Xero: the
 // customers and the sales invoices in Flow's own copy. It never calls Xero, so
@@ -10,6 +9,11 @@ import { MIRROR_RESOURCES } from './mirror.js';
 // stops counting as proof.
 export const MIRROR_FRESH_MS = 24 * 60 * 60 * 1000;
 
+// The copies that prove whether Xero holds an invoice for a job. Payments do
+// not: a connection without a payments scope (the default) never copies them,
+// and must still match jobs.
+export const PROOF_RESOURCES = Object.freeze(['invoices', 'credit_notes']);
+
 export async function listCustomers(db, organisationId) {
   const { rows } = await db.execute(sql`
     select xero_contact_id, name, status from xero_contacts
@@ -26,7 +30,7 @@ export async function mirrorState(db, organisationId, { now = new Date() } = {})
     where organisation_id = ${organisationId}`);
   const byResource = new Map(rows.map((r) => [r.resource, r]));
   const invoices = byResource.get('invoices');
-  const finished = MIRROR_RESOURCES.every((r) => (byResource.get(r)?.passes ?? 0) > 0);
+  const finished = PROOF_RESOURCES.every((r) => (byResource.get(r)?.passes ?? 0) > 0);
   const lastPass = invoices?.last_pass_finished_at ? new Date(invoices.last_pass_finished_at) : null;
   const { rows: [changed] } = await db.execute(sql`
     select max(last_changed_at) as at from xero_invoices where organisation_id = ${organisationId}`);

package/server/integrations/xero/migrations/0000_xero_connections.sql

@@ -1,6 +1,6 @@
 -- The Xero connection of each Flow organisation. The refresh token is
 -- AES-256-GCM ciphertext (XERO_TOKEN_KEY); the plain token is never stored.
-CREATE TABLE "xero_connections" (
+CREATE TABLE IF NOT EXISTS "xero_connections" (
 	"organisation_id" uuid PRIMARY KEY NOT NULL REFERENCES "organisations"("id"),
 	"mode" text NOT NULL,
 	"tenant_id" text NOT NULL,

package/server/integrations/xero/migrations/0001_xero_catalogue.sql

@@ -1,6 +1,6 @@
 -- Flow's copy of the Xero contacts and items of each connected organisation,
 -- and a record of each sync. Xero owns these records; a sync replaces the copy.
-CREATE TABLE "xero_contacts" (
+CREATE TABLE IF NOT EXISTS "xero_contacts" (
 	"organisation_id" uuid NOT NULL REFERENCES "organisations"("id"),
 	"xero_contact_id" text NOT NULL,
 	"name" text NOT NULL,
@@ -14,9 +14,9 @@ CREATE TABLE "xero_contacts" (
 	CONSTRAINT "xero_contacts_pk" PRIMARY KEY("organisation_id", "xero_contact_id")
 );
 --> statement-breakpoint
-CREATE INDEX "xero_contacts_org_name" ON "xero_contacts" ("organisation_id", lower("name"));
+CREATE INDEX IF NOT EXISTS "xero_contacts_org_name" ON "xero_contacts" ("organisation_id", lower("name"));
 --> statement-breakpoint
-CREATE TABLE "xero_items" (
+CREATE TABLE IF NOT EXISTS "xero_items" (
 	"organisation_id" uuid NOT NULL REFERENCES "organisations"("id"),
 	"xero_item_id" text NOT NULL,
 	"code" text NOT NULL,
@@ -32,7 +32,7 @@ CREATE TABLE "xero_items" (
 	CONSTRAINT "xero_items_org_code" UNIQUE("organisation_id", "code")
 );
 --> statement-breakpoint
-CREATE TABLE "xero_sync_runs" (
+CREATE TABLE IF NOT EXISTS "xero_sync_runs" (
 	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
 	"organisation_id" uuid NOT NULL REFERENCES "organisations"("id"),
 	"status" text DEFAULT 'running' NOT NULL,
@@ -46,4 +46,4 @@ CREATE TABLE "xero_sync_runs" (
 	CONSTRAINT "xero_sync_runs_status_valid" CHECK ("status" in ('running', 'succeeded', 'failed'))
 );
 --> statement-breakpoint
-CREATE INDEX "xero_sync_runs_org_started" ON "xero_sync_runs" ("organisation_id", "started_at");
+CREATE INDEX IF NOT EXISTS "xero_sync_runs_org_started" ON "xero_sync_runs" ("organisation_id", "started_at");

package/server/integrations/xero/migrations/0002_xero_invoice_pushes.sql

@@ -1,7 +1,7 @@
 -- One row for each issued Flow invoice version sent to Xero as a draft. It
 -- holds the exact request and its Idempotency-Key from before the request
 -- leaves, so an uncertain outcome is resolved without a second invoice.
-CREATE TABLE "xero_invoice_pushes" (
+CREATE TABLE IF NOT EXISTS "xero_invoice_pushes" (
 	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
 	"organisation_id" uuid NOT NULL,
 	"invoice_id" uuid NOT NULL,
@@ -29,4 +29,4 @@ CREATE TABLE "xero_invoice_pushes" (
 	CONSTRAINT "xero_invoice_pushes_settled_has_id" CHECK ("state" in ('dispatching', 'ambiguous') or "xero_invoice_id" is not null)
 );
 --> statement-breakpoint
-CREATE INDEX "xero_invoice_pushes_org_invoice" ON "xero_invoice_pushes" ("organisation_id", "invoice_id");
+CREATE INDEX IF NOT EXISTS "xero_invoice_pushes_org_invoice" ON "xero_invoice_pushes" ("organisation_id", "invoice_id");

package/server/integrations/xero/migrations/0003_xero_payment_cursors.sql

@@ -1,6 +1,6 @@
 -- Where the next read of Xero payments starts, for each Flow organisation.
 -- (This is the Xero adapter's own migration journal, not the core's.)
-CREATE TABLE "xero_payment_cursors" (
+CREATE TABLE IF NOT EXISTS "xero_payment_cursors" (
 	"organisation_id" uuid PRIMARY KEY NOT NULL REFERENCES "organisations"("id"),
 	"payments_since" timestamp with time zone NOT NULL,
 	"updated_at" timestamp with time zone DEFAULT now() NOT NULL

package/server/integrations/xero/migrations/0004_xero_mirror.sql

@@ -4,7 +4,7 @@
 -- without spending Xero calls. A row is upserted by its Xero id, and changes
 -- only when its content hash changes. Free text (references, line
 -- descriptions) is kept only with XERO_KEEP_REFERENCE=on.
-CREATE TABLE "xero_invoices" (
+CREATE TABLE IF NOT EXISTS "xero_invoices" (
 	"organisation_id" uuid NOT NULL REFERENCES "organisations"("id"),
 	"xero_invoice_id" text NOT NULL,
 	"type" text NOT NULL,
@@ -30,11 +30,11 @@ CREATE TABLE "xero_invoices" (
 	CONSTRAINT "xero_invoices_pk" PRIMARY KEY("organisation_id", "xero_invoice_id")
 );
 --> statement-breakpoint
-CREATE INDEX "xero_invoices_number" ON "xero_invoices" ("organisation_id", "invoice_number");
+CREATE INDEX IF NOT EXISTS "xero_invoices_number" ON "xero_invoices" ("organisation_id", "invoice_number");
 --> statement-breakpoint
-CREATE INDEX "xero_invoices_contact" ON "xero_invoices" ("organisation_id", "xero_contact_id", "issued_on");
+CREATE INDEX IF NOT EXISTS "xero_invoices_contact" ON "xero_invoices" ("organisation_id", "xero_contact_id", "issued_on");
 --> statement-breakpoint
-CREATE TABLE "xero_credit_notes" (
+CREATE TABLE IF NOT EXISTS "xero_credit_notes" (
 	"organisation_id" uuid NOT NULL REFERENCES "organisations"("id"),
 	"xero_credit_note_id" text NOT NULL,
 	"type" text NOT NULL,
@@ -57,7 +57,7 @@ CREATE TABLE "xero_credit_notes" (
 	CONSTRAINT "xero_credit_notes_pk" PRIMARY KEY("organisation_id", "xero_credit_note_id")
 );
 --> statement-breakpoint
-CREATE TABLE "xero_payments" (
+CREATE TABLE IF NOT EXISTS "xero_payments" (
 	"organisation_id" uuid NOT NULL REFERENCES "organisations"("id"),
 	"xero_payment_id" text NOT NULL,
 	"payment_type" text,
@@ -75,12 +75,12 @@ CREATE TABLE "xero_payments" (
 	CONSTRAINT "xero_payments_pk" PRIMARY KEY("organisation_id", "xero_payment_id")
 );
 --> statement-breakpoint
-CREATE INDEX "xero_payments_invoice" ON "xero_payments" ("organisation_id", "xero_invoice_id");
+CREATE INDEX IF NOT EXISTS "xero_payments_invoice" ON "xero_payments" ("organisation_id", "xero_invoice_id");
 --> statement-breakpoint
 -- Where the next read of each resource starts. `modified_since` is the
 -- keyset: the next read asks Xero for records changed since then, oldest
 -- change first. `page` moves on only when one second holds a full page.
-CREATE TABLE "xero_mirror_cursors" (
+CREATE TABLE IF NOT EXISTS "xero_mirror_cursors" (
 	"organisation_id" uuid NOT NULL REFERENCES "organisations"("id"),
 	"resource" text NOT NULL,
 	"modified_since" timestamp with time zone,

package/server/integrations/xero/migrations/0005_xero_send_modes.sql

@@ -2,9 +2,15 @@
 -- sent approved, whether Xero emailed it to the customer. Xero's email action
 -- is not idempotent, so Flow records `sending` before the call and retries
 -- only a refusal (`failed`), never an unknown outcome.
-ALTER TABLE "xero_invoice_pushes" ADD COLUMN "send_mode" text DEFAULT 'accounting_draft' NOT NULL;--> statement-breakpoint
-ALTER TABLE "xero_invoice_pushes" ADD COLUMN "email_state" text;--> statement-breakpoint
-ALTER TABLE "xero_invoice_pushes" ADD COLUMN "email_error" text;--> statement-breakpoint
-ALTER TABLE "xero_invoice_pushes" ADD COLUMN "emailed_at" timestamp with time zone;--> statement-breakpoint
-ALTER TABLE "xero_invoice_pushes" ADD CONSTRAINT "xero_invoice_pushes_send_mode_valid" CHECK ("send_mode" in ('accounting_draft', 'approve_and_email'));--> statement-breakpoint
-ALTER TABLE "xero_invoice_pushes" ADD CONSTRAINT "xero_invoice_pushes_email_state_valid" CHECK ("email_state" is null or "email_state" in ('pending', 'sending', 'sent', 'failed', 'unknown'));
+ALTER TABLE "xero_invoice_pushes" ADD COLUMN IF NOT EXISTS "send_mode" text DEFAULT 'accounting_draft' NOT NULL;--> statement-breakpoint
+ALTER TABLE "xero_invoice_pushes" ADD COLUMN IF NOT EXISTS "email_state" text;--> statement-breakpoint
+ALTER TABLE "xero_invoice_pushes" ADD COLUMN IF NOT EXISTS "email_error" text;--> statement-breakpoint
+ALTER TABLE "xero_invoice_pushes" ADD COLUMN IF NOT EXISTS "emailed_at" timestamp with time zone;--> statement-breakpoint
+DO $flow_guard$ BEGIN
+	ALTER TABLE "xero_invoice_pushes" ADD CONSTRAINT "xero_invoice_pushes_send_mode_valid" CHECK ("send_mode" in ('accounting_draft', 'approve_and_email'));
+EXCEPTION WHEN duplicate_object OR duplicate_table OR invalid_table_definition THEN NULL;
+END $flow_guard$;--> statement-breakpoint
+DO $flow_guard$ BEGIN
+	ALTER TABLE "xero_invoice_pushes" ADD CONSTRAINT "xero_invoice_pushes_email_state_valid" CHECK ("email_state" is null or "email_state" in ('pending', 'sending', 'sent', 'failed', 'unknown'));
+EXCEPTION WHEN duplicate_object OR duplicate_table OR invalid_table_definition THEN NULL;
+END $flow_guard$;

package/server/ui/app-page.js

@@ -34,14 +34,16 @@ const BODY = `<div class="fx-app">
     <div class="fx-card fx-message__card fx-state-no-access" id="no-access"></div>
   </section>
 
-  <div class="fx-state-signed-in fx-shell">
+  <div class="fx-state-signed-in fx-shell" id="shell">
     <aside class="fx-side">
-      <a class="fx-brand" href="/">${FLOW_MARK}<span>Flow</span></a>
+      <div class="fx-side__head">
+        <a class="fx-brand" href="/">${FLOW_MARK}<span>Flow</span></a>
+        <button type="button" class="fx-btn fx-btn--ghost fx-btn--icon" id="menu-toggle" aria-controls="nav" aria-label="Menu"></button>
+      </div>
       <nav class="fx-nav" id="nav" aria-label="Flow"></nav>
       <div class="fx-side__end">
         <div id="user-button" class="fx-side__user"></div>
-        <button type="button" class="fx-btn fx-btn--ghost fx-btn--icon" id="report-problem" title="Report a problem" aria-label="Report a problem" hidden></button>
-        <button type="button" class="fx-btn fx-btn--ghost fx-btn--icon fx-mode-toggle" data-mode-toggle>Light or dark</button>
+        <button type="button" class="fx-btn fx-btn--ghost fx-btn--icon" id="search" title="Search (Ctrl+K)" aria-label="Search" aria-keyshortcuts="Control+K Meta+K"></button>
       </div>
     </aside>
     <main id="main" class="fx-main" tabindex="-1"></main>