@arcforgelabs/flow 2026.10.33 → 2026.10.35

package/README.md

@@ -31,18 +31,24 @@ run a lab.
 | `CHANGELOG.md` | What changed in each release: an index of one file per release in `CHANGELOG/` |
 | `SECURITY.md` | How to report a security problem, the trust model, and the rules held hard |
 | `LICENSE` | MIT licence |
+| `docs/docs.json` | The docs site navigation. `docs/` is published at https://arcforgelabs.github.io/docs/flow/ by arcforgelabs/docs |
+| `docs/index.md` | The docs site home page |
+| `docs/releases/` | One release notes page per version (`<version>.md`), shown on the docs site |
 | `docs/DESIGN.md` | The design systems (theme families), how pages and Clerk's components take them, and the screens |
 | `docs/DATA_MODEL.md` | The PostgreSQL records, the rules the database holds, and how to change the schema |
 | `docs/DATA_SPINE.md` | The design of the tables and jobs every integration shares: mirror, identity map, job queue, outbox, review queue |
 | `docs/JOB_INVOICE_LINKS.md` | The pipeline: how each job links to its customer and to the accounting invoice that bills it |
 | `docs/INVOICING_RULES.md` | The invoicing rules that draft a job's invoice, and the two ways an invoice goes to Xero |
 | `docs/INVOICE_RULES.md` | Invoice rules a lab builds (When, If, Then) that make a ready job wait or never draft |
-| `docs/INVOICE_SENDING.md` | Drafts, Problem and Ready invoices, Mark ready, and Send all ready to the accounting system |
+| `docs/INVOICE_SENDING.md` | Drafts, Problem and Ready invoices, Finalise, a changed job, and Send all ready to the accounting system |
 | `docs/RECONCILE.md` | The daily reconcile: counts and totals per day across the work system's copy, the ledger and the accounting copy |
 | `docs/ALERTS.md` | Quiet alerts: the slim line on a page when something there needs a person, and how a person dismisses it |
 | `docs/AUTOMATIONS.md` | Automations: Flow routines that mark jobs ready to invoice and draft them, each on or off |
 | `docs/LINE_MAPPING.md` | Line mapping: how each work system line finds its price item, and Price codes in Settings |
+| `docs/CUSTOM_FIELDS.md` | Custom fields: the lab's own fields for its jobs, kept in Flow only, and how a board move checks for conflicts |
+| `docs/JOB_BOARD_MOVES.md` | Moving jobs on the Jobs board: custom field moves stay in Flow; Seazona stage moves become a hand-off |
 | `docs/PRICE_LIST.md` | The price list: Flow's own codes and prices, their links to Xero items and Seazona products, and the price check |
+| `docs/LOW_RISK_MERGE.md` | The low-risk merge lane: which pull requests merge themselves when green, with ClawSweeper's risk labels |
 | `docs/RELEASING.md` | Versions and channels, the release workflows, how to cut and roll back a release, and the one-time setup |
 | `docs/SELF_HOSTING.md` | Running a Flow release with Docker, Node or Replit, the update notice, and Clerk sign-in |
 | `docs/REPLIT.md` | A Replit workspace of this repository that follows a release channel (`FLOW_DEPLOY_REF`) |

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcforgelabs/flow",
-  "version": "2026.10.33",
+  "version": "2026.10.35",
   "description": "Invoicing, bill entry and a financial dashboard for labs, with Seazona and Xero integrations.",
   "license": "MIT",
   "repository": {
@@ -32,6 +32,7 @@
     "start": "node server/index.js",
     "test": "node --test --test-concurrency=1 test/*.test.js",
     "changelog:check": "node scripts/release/changelog.mjs check",
+    "release:stable": "node scripts/release/release-stable.mjs",
     "theme:contrast": "node scripts/theme-contrast.mjs",
     "db:generate": "drizzle-kit generate && node scripts/db-guard-migrations.js"
   },

package/server/api/custom-fields.js

@@ -0,0 +1,115 @@
+import express from 'express';
+import {
+  CUSTOM_FIELD_TYPES, GROUPABLE_TYPES, OPTION_COLORS, archiveField, choosablePeople, createField, jobFieldHistory, listFields,
+  listJobFieldValues, orderFields, setJobFieldValue, updateField,
+} from '../core/custom-fields.js';
+import { FlowError } from '../core/errors.js';
+import { resolveOrganisation } from './invoicing.js';
+
+// Custom fields for jobs (server/core/custom-fields.js, docs/CUSTOM_FIELDS.md).
+//
+//   GET  /api/custom-fields[?archived=1]          the lab's fields, the work systems' own fields (read only),
+//        and the people a person field can name
+//   POST /api/custom-fields { name, type[, options] }        owner or admin: make a field
+//   PUT  /api/custom-fields/order { ids }                   owner or admin: the field order
+//   PUT  /api/custom-fields/:id { name?, options? }         owner or admin: rename, change options
+//   POST /api/custom-fields/:id/archive { archived }        owner or admin: archive or bring back
+//   GET  /api/custom-fields/values                          every job's values
+//   PUT  /api/custom-fields/values { sourceSystem, sourceJobRef, fieldId, value[, expectedUpdatedAt] }
+//        set one job's value; a stale expectedUpdatedAt gives 409 with the current value
+//   GET  /api/custom-fields/history?sourceSystem=&sourceJobRef=   one job's changes, newest first
+//
+// Every route also takes `organisationId` (query or body) when the
+// installation has more than one organisation. A value lives only in Flow:
+// no route here writes to an integration.
+//
+// `work()` is the work system adapters that offer listWork; their job
+// statuses show as a read-only Stage field.
+const ERROR_STATUS = { not_found: 404, conflict: 409, organisation_required: 409 };
+
+export function createCustomFieldsRouter({ db, personAuth, work = () => [], log = console }) {
+  const router = express.Router();
+  router.use(express.json({ limit: '32kb' }));
+  const signedIn = [personAuth.requireSession];
+  const manager = [...signedIn, personAuth.requireRole('owner', 'admin')];
+
+  const handle = (fn) => async (req, res) => {
+    try {
+      res.set('Cache-Control', 'no-store');
+      await fn(req, res);
+    } catch (error) {
+      if (!(error instanceof FlowError)) {
+        log.error?.(`[custom-fields] ${error.message}`);
+        return res.status(500).json({ ok: false, code: 'internal', error: 'Something went wrong.' });
+      }
+      const body = { ok: false, code: error.code, error: error.message };
+      if (error.details !== undefined) body.details = error.details;
+      return res.status(ERROR_STATUS[error.code] ?? 400).json(body);
+    }
+  };
+  const organisationOf = (req) => resolveOrganisation(db, req.body?.organisationId ?? req.query.organisationId);
+
+  // The work systems' own fields: their job statuses, as the Stage lanes on
+  // the Jobs board. Read from Flow's copy; a work system that fails to answer
+  // is left out, not an error.
+  async function systemFields() {
+    const fields = [];
+    for (const adapter of work()) {
+      try {
+        const { statuses = [] } = await adapter.capabilities.listWork();
+        fields.push({
+          id: `${adapter.id}:stage`, source: adapter.id, sourceLabel: adapter.name ?? adapter.id, name: 'Stage',
+          type: 'dropdown', readOnly: true, options: statuses.map((s) => ({ id: s.label, name: s.label, final: Boolean(s.final) })),
+        });
+      } catch (error) {
+        log.warn?.(`[custom-fields] ${adapter.id} stages: ${error.message}`);
+      }
+    }
+    return fields;
+  }
+
+  router.get('/', ...signedIn, handle(async (req, res) => {
+    const organisationId = await organisationOf(req);
+    const archived = req.query.archived === '1' || req.query.archived === 'true';
+    const [fields, system, chosen] = await Promise.all([listFields(db, organisationId, { archived }), systemFields(), choosablePeople(db)]);
+    res.json({ ok: true, fields, systemFields: system, people: chosen, types: CUSTOM_FIELD_TYPES, groupable: GROUPABLE_TYPES, colors: OPTION_COLORS });
+  }));
+
+  router.post('/', ...manager, handle(async (req, res) => {
+    const field = await createField(db, await organisationOf(req), req.body, { personId: req.person.id });
+    res.status(201).json({ ok: true, field });
+  }));
+
+  router.put('/order', ...manager, handle(async (req, res) => {
+    const fields = await orderFields(db, await organisationOf(req), req.body?.ids, { personId: req.person.id });
+    res.json({ ok: true, fields });
+  }));
+
+  router.get('/values', ...signedIn, handle(async (req, res) => {
+    res.json({ ok: true, values: await listJobFieldValues(db, await organisationOf(req)) });
+  }));
+
+  router.put('/values', ...signedIn, handle(async (req, res) => {
+    const value = await setJobFieldValue(db, await organisationOf(req), req.body, { personId: req.person.id });
+    res.json({ ok: true, value });
+  }));
+
+  router.get('/history', ...signedIn, handle(async (req, res) => {
+    const history = await jobFieldHistory(db, await organisationOf(req), req.query);
+    res.json({ ok: true, history });
+  }));
+
+  router.put('/:id', ...manager, handle(async (req, res) => {
+    const field = await updateField(db, await organisationOf(req), req.params.id, req.body, { personId: req.person.id });
+    res.json({ ok: true, field });
+  }));
+
+  router.post('/:id/archive', ...manager, handle(async (req, res) => {
+    const archived = req.body?.archived ?? true;
+    if (typeof archived !== 'boolean') throw new FlowError('invalid', 'archived must be true or false');
+    const field = await archiveField(db, await organisationOf(req), req.params.id, { archived, personId: req.person.id });
+    res.json({ ok: true, field });
+  }));
+
+  return router;
+}

package/server/api/invoicing.js

@@ -21,7 +21,9 @@ import { jobReference } from '../core/references.js';
 import {
   acceptFindings, archivePriceItem, checkPrices, createPriceItem, linkPriceItem, readCatalogues, readPriceList, unlinkPriceItem, updatePriceItem,
 } from '../core/price-list.js';
-import { draftInvoiceForObligation, explainObligation, listObligations, setReady, useSourceLines } from '../core/ledger.js';
+import {
+  draftInvoiceForObligation, explainObligation, jobChangeFor, listObligations, setReady, useSourceLines,
+} from '../core/ledger.js';
 import { isHistoryHeld } from '../core/history.js';
 import { invoicePdfDocument, pdfFields, pdfFilename, renderInvoicePdf } from '../core/invoice-pdf.js';
 import { invoiceView, invoiceViews, markNotReady, markReady, sendAgain, sendAllReady } from '../core/sending.js';
@@ -241,15 +243,37 @@ async function jobsByInvoice(db, organisationId, invoiceIds) {
   return new Map(rows.map((o) => [o.invoiceId, jobOf(o)]));
 }
 
-async function invoiceDetail(db, organisationId, invoiceId, accounting = null) {
+// The job changed after its invoice was made (ledger.js, jobChangeFor): what
+// changed, with customer names, and the work system's link to the job.
+async function jobChangeDetail(db, organisationId, invoiceId, work) {
+  const change = await jobChangeFor(db, organisationId, invoiceId);
+  if (!change) return null;
+  let contact = null;
+  if (change.contact) {
+    const ids = [change.contact.was, change.contact.now].filter(Boolean);
+    const rows = ids.length ? await db.select({ id: contacts.id, name: contacts.name }).from(contacts)
+      .where(and(eq(contacts.organisationId, organisationId), inArray(contacts.id, ids))) : [];
+    const nameOf = (id) => rows.find((r) => r.id === id)?.name ?? null;
+    contact = { was: nameOf(change.contact.was), now: nameOf(change.contact.now) };
+  }
+  const source = work.find((a) => a.id === change.sourceSystem) ?? null;
+  const link = typeof source?.capabilities.jobLink === 'function'
+    ? source.capabilities.jobLink({ sourceJobRef: change.sourceJobRef, sourceInvoiceRef: change.sourceInvoiceRef })
+    : null;
+  return { ...change, contact, systemName: source?.name ?? change.sourceSystem, link: link ?? null };
+}
+
+async function invoiceDetail(db, organisationId, invoiceId, accounting = null, work = []) {
   const invoice = await getInvoice(db, organisationId, invoiceId);
-  const [[contact], versions, jobs] = await Promise.all([
+  const [[contact], versions, jobs, jobChange] = await Promise.all([
     db.select({ id: contacts.id, name: contacts.name, email: contacts.email }).from(contacts)
       .where(and(eq(contacts.organisationId, organisationId), eq(contacts.id, invoice.contactId))),
     listInvoiceVersions(db, organisationId, invoiceId),
     jobsByInvoice(db, organisationId, [invoiceId]),
+    jobChangeDetail(db, organisationId, invoiceId, work),
   ]);
   return {
+    jobChange,
     ...invoice,
     ...(await invoiceView(db, organisationId, invoice, { accounting })),
     // Where a draft goes when it is sent, and how: this customer's send mode.
@@ -277,7 +301,8 @@ export function createInvoicingRouter({
     const rows = await db.select({
       id: organisations.id, name: organisations.name, invoicePrefix: organisations.invoicePrefix, nextInvoiceNumber: organisations.nextInvoiceNumber,
     }).from(organisations).orderBy(asc(organisations.name));
-    res.json({ ok: true, organisations: rows, canIssue: ['owner', 'admin'].includes(req.person.role) });
+    // sendsTo: the accounting system a sent invoice goes to, or null.
+    res.json({ ok: true, organisations: rows, canIssue: ['owner', 'admin'].includes(req.person.role), sendsTo: accounting()?.name ?? null });
   }));
 
   router.get('/invoices', ...signedIn, handle(log, async (req, res) => {
@@ -385,7 +410,7 @@ export function createInvoicingRouter({
   router.get('/invoices/:id', ...signedIn, handle(log, async (req, res) => {
     const invoiceId = pathId(req.params.id, 'invoice');
     const organisationId = await organisationOf(req);
-    res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting()) });
+    res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting(), work()) });
   }));
 
   router.get('/invoices/:id/pdf', ...signedIn, handle(log, async (req, res) => {
@@ -414,7 +439,7 @@ export function createInvoicingRouter({
       lines: body.lines === undefined ? [] : readLines(body.lines),
     });
     log.info?.(`[invoicing] organisation ${organisationId}: person ${req.person.id} made draft invoice ${draft.id}`);
-    res.status(201).json({ ok: true, invoice: await invoiceDetail(db, organisationId, draft.id, accounting()) });
+    res.status(201).json({ ok: true, invoice: await invoiceDetail(db, organisationId, draft.id, accounting(), work()) });
   }));
 
   router.patch('/invoices/:id', ...signedIn, handle(log, async (req, res) => {
@@ -428,16 +453,22 @@ export function createInvoicingRouter({
     if (body.lines !== undefined) changes.lines = readLines(body.lines);
     if (!Object.keys(changes).length) throw invalid('nothing to change: send contactId, reference, dueDate or lines');
     await updateDraftInvoice(db, organisationId, invoiceId, changes);
-    res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting()) });
+    res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting(), work()) });
   }));
 
   router.post('/invoices/:id/issue', ...manager, handle(log, async (req, res) => {
     const invoiceId = pathId(req.params.id, 'invoice');
     const organisationId = await organisationOf(req);
     const issueDate = optionalDate(req.body?.issueDate, 'issueDate') ?? today();
+    // A draft whose job changed after it was made waits for a person to fix
+    // the job at its source or adopt the change (ledger.js), as Move to
+    // Ready and Send do.
+    const { problems } = await invoiceView(db, organisationId, await getInvoice(db, organisationId, invoiceId));
+    const held = problems.find((p) => p.code === 'job_review');
+    if (held) throw new FlowError('not_ready', `${held.message} Nothing was finalised.`);
     const issued = await issueInvoice(db, organisationId, invoiceId, { issuedBy: `person:${req.person.id}`, issueDate });
     log.info?.(`[invoicing] organisation ${organisationId}: person ${req.person.id} issued invoice ${issued.number} (version ${issued.issuedVersion})`);
-    res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting()) });
+    res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting(), work()) });
   }));
 
   router.post('/invoices/:id/revise', ...manager, handle(log, async (req, res) => {
@@ -445,7 +476,7 @@ export function createInvoicingRouter({
     const organisationId = await organisationOf(req);
     await reviseInvoice(db, organisationId, invoiceId);
     log.info?.(`[invoicing] organisation ${organisationId}: person ${req.person.id} opened invoice ${invoiceId} for revision`);
-    res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting()) });
+    res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting(), work()) });
   }));
 
   router.post('/invoices/:id/void', ...manager, handle(log, async (req, res) => {
@@ -453,7 +484,7 @@ export function createInvoicingRouter({
     const organisationId = await organisationOf(req);
     await voidInvoice(db, organisationId, invoiceId);
     log.info?.(`[invoicing] organisation ${organisationId}: person ${req.person.id} voided invoice ${invoiceId}`);
-    res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting()) });
+    res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting(), work()) });
   }));
 
   router.get('/contacts', ...signedIn, handle(log, async (req, res) => {
@@ -524,7 +555,7 @@ export function createInvoicingRouter({
     const reference = obligation ? await jobReference(db, organisationId, obligation, { template, work: source }) : null;
     const { invoice } = await draftInvoiceForObligation(db, organisationId, obligationId, { liveCheck, actor: `person:${req.person.id}`, reference });
     log.info?.(`[invoicing] organisation ${organisationId}: person ${req.person.id} drafted invoice ${invoice.id} from job ${obligationId}`);
-    res.status(201).json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoice.id) });
+    res.status(201).json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoice.id, accounting(), work()) });
   }));
 
   // "Use new lines": the job changed in the work system after its draft was
@@ -533,7 +564,7 @@ export function createInvoicingRouter({
     const obligationId = pathId(req.params.id, 'job');
     const organisationId = await organisationOf(req);
     const { invoice } = await useSourceLines(db, organisationId, obligationId, { actor: `person:${req.person.id}` });
-    res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoice.id) });
+    res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoice.id, accounting(), work()) });
   }));
 
   router.post('/jobs/:id/ready', ...signedIn, handle(log, async (req, res) => {

package/server/api/work-moves.js

@@ -0,0 +1,80 @@
+import express from 'express';
+import { FlowError } from '../core/errors.js';
+
+// Jobs board moves that belong to the work system (docs/JOB_BOARD_MOVES.md).
+//
+//   POST /api/work/moves { sourceSystem, sourceJobRef, toStatus }
+//        a person moved a job to another stage: the work system answers what
+//        happens. Seazona's API cannot change a stage, so it answers a
+//        hand-off: what to do in Seazona, and how long Flow waits.
+//   POST /api/work/moves/cancel { sourceSystem, sourceJobRef }   take back a waiting move
+//   GET  /api/work/my-settings[?integration=]                    this person's own integration choices
+//   PUT  /api/work/my-settings { integration, key, value }        change one
+//
+// A move of a Flow custom field never comes here: that is
+// PUT /api/custom-fields/values, and it stays in Flow.
+//
+// `adapters(capability)` is the enabled, ready adapters that offer it.
+const ERROR_STATUS = { not_found: 404, conflict: 409, not_supported: 409 };
+const SYSTEM = /^[a-z][a-z0-9-]{1,31}$/;
+
+export function createWorkMovesRouter({ adapters = () => [], personAuth, log = console }) {
+  const router = express.Router();
+  router.use(express.json({ limit: '8kb' }));
+  const signedIn = [personAuth.requireSession];
+
+  const handle = (fn) => async (req, res) => {
+    try {
+      res.set('Cache-Control', 'no-store');
+      await fn(req, res);
+    } catch (error) {
+      if (!(error instanceof FlowError)) {
+        log.error?.(`[work-moves] ${error.message}`);
+        return res.status(500).json({ ok: false, code: 'internal', error: 'Something went wrong.' });
+      }
+      return res.status(ERROR_STATUS[error.code] ?? 400).json({ ok: false, code: error.code, error: error.message });
+    }
+  };
+
+  // The enabled adapter `id` that offers `capability`.
+  const adapterFor = (id, capability) => {
+    if (typeof id !== 'string' || !SYSTEM.test(id)) throw new FlowError('invalid', 'name an integration');
+    const adapter = adapters(capability).find((a) => a.id === id) ?? null;
+    if (!adapter) throw new FlowError('not_supported', 'that integration is not on, or cannot do that');
+    return adapter;
+  };
+  const jobRef = (raw) => {
+    const ref = typeof raw === 'string' ? raw.trim() : '';
+    if (!ref || ref.length > 200) throw new FlowError('invalid', 'sourceJobRef is required');
+    return ref;
+  };
+
+  router.post('/moves', ...signedIn, handle(async (req, res) => {
+    const adapter = adapterFor(req.body?.sourceSystem, 'moveWork');
+    const move = await adapter.capabilities.moveWork({ sourceJobRef: jobRef(req.body?.sourceJobRef), toStatus: req.body?.toStatus, personId: req.person.id });
+    res.json({ ok: true, move });
+  }));
+
+  router.post('/moves/cancel', ...signedIn, handle(async (req, res) => {
+    const adapter = adapterFor(req.body?.sourceSystem, 'cancelMove');
+    res.json({ ok: true, ...(await adapter.capabilities.cancelMove({ sourceJobRef: jobRef(req.body?.sourceJobRef) })) });
+  }));
+
+  router.get('/my-settings', ...signedIn, handle(async (req, res) => {
+    const wanted = typeof req.query.integration === 'string' ? req.query.integration : null;
+    const out = [];
+    for (const adapter of adapters('personSettings')) {
+      if (wanted && adapter.id !== wanted) continue;
+      out.push({ integration: adapter.id, name: adapter.name, settings: await adapter.capabilities.personSettings({ personId: req.person.id }) });
+    }
+    res.json({ ok: true, integrations: out });
+  }));
+
+  router.put('/my-settings', ...signedIn, handle(async (req, res) => {
+    const adapter = adapterFor(req.body?.integration, 'setPersonSetting');
+    const settings = await adapter.capabilities.setPersonSetting({ personId: req.person.id, key: req.body?.key, value: req.body?.value });
+    res.json({ ok: true, integration: adapter.id, settings });
+  }));
+
+  return router;
+}

package/server/app.js

@@ -1,5 +1,7 @@
 import express from 'express';
 import { createAlertsRouter } from './api/alerts.js';
+import { createCustomFieldsRouter } from './api/custom-fields.js';
+import { createWorkMovesRouter } from './api/work-moves.js';
 import { createConnectorApi } from './api/connector.js';
 import { createInvoicingRouter } from './api/invoicing.js';
 import { createSignInRouter } from './auth/routes.js';
@@ -35,6 +37,8 @@ import { createUiAssetsRouter } from './ui/routes.js';
 // the migration journals this build ships (server/db/doctor.js): GET /health
 // reports how many of each the database has applied, so the workspace's
 // doctor can tell what Replit's publish step will offer (docs/REPLIT.md).
+// `tracing` (server/core/tracing.js) names each request's performance trace
+// by its route, while a tracing service is on.
 export function createApp({
   build = deployedBuildStatus(),
   database = null,
@@ -49,10 +53,12 @@ export function createApp({
   clerkProxyRateLimitPerMinute = 300,
   defaultFamily = DEFAULT_FAMILY,
   log = console,
+  tracing = null,
 } = {}) {
   const app = express();
   app.disable('x-powered-by');
   app.set('trust proxy', trustProxy);
+  if (tracing) app.use(tracing.requests());
 
   app.get('/health', async (_req, res) => {
     let databaseOk = null;
@@ -136,6 +142,12 @@ export function createApp({
     // items, Seazona products).
     const priceSystems = () => integrations?.with('listPriceItems') ?? [];
     app.use('/api/invoicing', createInvoicingRouter({ db: database.db, personAuth: auth.personAuth, log, liveCheckFor, accounting, work, priceSystems }));
+    // Custom fields for jobs (server/core/custom-fields.js): kept in Flow
+    // only; the work systems' statuses show beside them, read only.
+    app.use('/api/custom-fields', createCustomFieldsRouter({ db: database.db, personAuth: auth.personAuth, work, log }));
+    // Stage moves the work system must make, and each person's own
+    // integration choices (server/api/work-moves.js).
+    app.use('/api/work', createWorkMovesRouter({ adapters: (capability) => integrations?.with(capability) ?? [], personAuth: auth.personAuth, log }));
     // Quiet alerts (server/core/alerts.js): what needs a person on each page.
     // Integrations add their own through the `alerts` capability.
     app.use('/api/alerts', createAlertsRouter({

package/server/auth/people.js

@@ -2,6 +2,7 @@ import { and, asc, eq, isNull, ne, sql } from 'drizzle-orm';
 import { people, PERSON_ROLES } from '../db/schema.js';
 import { FlowError } from '../core/errors.js';
 import { isThemeFamily, normalizeAccent } from '../theme/themes.js';
+import { normaliseJobsView } from '../ui/job-view.js';
 import { isPlainEmail } from './settings.js';
 
 // The people who may sign in, and their roles. Only an owner changes this
@@ -50,6 +51,40 @@ export async function setPersonAppearance(db, { id, appearance }) {
   return row.appearance;
 }
 
+// The pages a person can keep their own view of, each with its check.
+// Each page is named in a switch, never looked up by the name a request
+// sends, so a name such as "constructor" can only be refused.
+function viewCheck(page) {
+  switch (page) {
+    case 'jobs': return normaliseJobsView;
+    default: return null;
+  }
+}
+const VIEW_PAGE_NAMES = ['jobs'];
+
+// A person's saved views as Flow sends them: only the known pages, each
+// checked, so a view saved by an older Flow still loads.
+export function normaliseViews(input) {
+  const value = input && typeof input === 'object' ? input : {};
+  const out = {};
+  for (const page of VIEW_PAGE_NAMES) if (value[page]) out[page] = viewCheck(page)(value[page]);
+  return out;
+}
+
+// Each person keeps their own view of a page; saving one page leaves the
+// others as they were.
+export async function setPersonView(db, { id, page, view }) {
+  const normalise = viewCheck(page);
+  if (typeof normalise !== 'function') throw new FlowError('not_found', 'no such page');
+  const value = normalise(view);
+  const [row] = await db.update(people)
+    .set({ views: sql`coalesce(${people.views}, '{}'::jsonb) || ${JSON.stringify({ [page]: value })}::jsonb`, updatedAt: new Date() })
+    .where(eq(people.id, id))
+    .returning();
+  if (!row) throw new FlowError('not_found', 'person not found');
+  return value;
+}
+
 export async function findPersonById(db, id) {
   const [row] = await db.select().from(people).where(eq(people.id, id));
   return row ?? null;

package/server/auth/routes.js

@@ -8,9 +8,11 @@ import {
   listPeople,
   normaliseEmail,
   normaliseAppearance,
+  normaliseViews,
   publicPerson,
   removePerson,
   setPersonAppearance,
+  setPersonView,
   updatePerson,
 } from './people.js';
 import { isPlainEmail } from './settings.js';
@@ -99,6 +101,7 @@ export function createSignInRouter({ settings, db, clerk, personAuth, defaultFam
       body.ownerActions = { allowed: Boolean(check.verified), by: check.by ?? null };
     }
     body.appearance = req.person.appearance ? normaliseAppearance(req.person.appearance) : null;
+    body.views = normaliseViews(req.person.views);
     res.json(body);
   });
 
@@ -112,6 +115,17 @@ export function createSignInRouter({ settings, db, clerk, personAuth, defaultFam
     }
   });
 
+  // Each person sets their own view of a page (how Jobs groups, sorts and
+  // filters); it follows their account.
+  router.put('/api/me/views/:page', requireSession, express.json({ limit: '8kb' }), async (req, res) => {
+    try {
+      const view = await setPersonView(db, { id: req.person.id, page: req.params.page, view: req.body });
+      res.json({ ok: true, view });
+    } catch (error) {
+      sendError(res, error, log);
+    }
+  });
+
   // Only an owner manages people.
   const people = express.Router();
   people.use(requireSession, requireOwner, express.json({ limit: '16kb' }));