@arcforgelabs/flow 2026.10.32 → 2026.10.34

package/README.md

@@ -27,9 +27,13 @@ run a lab.
 | --- | --- |
 | `VISION.md` | What Flow is for, the core and its integrations, and what it will not do |
 | `AGENTS.md` | Agent entry point (`CLAUDE.md` links to it) |
-| `CONTRIBUTING.md` | How to file issues and pull requests, porting rules, merging |
+| `CONTRIBUTING.md` | How to file issues and pull requests, porting rules, the changelog, merging |
+| `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 |
@@ -37,10 +41,14 @@ run a lab.
 | `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/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.32",
+  "version": "2026.10.34",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@arcforgelabs/flow",
-      "version": "2026.10.32",
+      "version": "2026.10.34",
       "license": "MIT",
       "dependencies": {
         "@clerk/backend": "3.23.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcforgelabs/flow",
-  "version": "2026.10.32",
+  "version": "2026.10.34",
   "description": "Invoicing, bill entry and a financial dashboard for labs, with Seazona and Xero integrations.",
   "license": "MIT",
   "repository": {
@@ -31,6 +31,7 @@
   "scripts": {
     "start": "node server/index.js",
     "test": "node --test --test-concurrency=1 test/*.test.js",
+    "changelog:check": "node scripts/release/changelog.mjs check",
     "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,114 @@
+import express from 'express';
+import {
+  CUSTOM_FIELD_TYPES, GROUPABLE_TYPES, OPTION_COLORS, archiveField, 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, and the work systems' own fields (read only)
+//   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] = await Promise.all([listFields(db, organisationId, { archived }), systemFields()]);
+    res.json({ ok: true, fields, systemFields: system, 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

@@ -16,11 +16,12 @@ import {
   saveCustomerBilling, saveInvoicingSettings, sendModeFor, sendModeSummary,
 } from '../core/invoicing-rules.js';
 import { boardJobs, describeObligations } from '../core/job-board.js';
+import { readBeforeAct } from '../core/read-before-act.js';
 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 } from '../core/ledger.js';
+import { draftInvoiceForObligation, explainObligation, 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';
@@ -276,7 +277,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) => {
@@ -287,25 +289,36 @@ export function createInvoicingRouter({
     }
     const q = text(req.query.q);
     const limit = limitOf(req.query.limit, 200, 500);
-    const views = await invoiceViews(db, organisationId, { accounting: accounting() });
-    const where = [eq(invoices.organisationId, organisationId)];
-    const only = (ids) => (ids.length ? inArray(invoices.id, ids) : sql`false`);
-    if (status === 'to_check') where.push(only(views.toCheck));
-    else if (status === 'ready') where.push(only(views.ready));
-    else if (status === 'problem') where.push(only([...views.problems.keys()]));
-    else if (status) where.push(eq(invoices.status, status));
-    if (q) {
-      const pattern = containing(q);
-      where.push(or(ilike(invoices.number, pattern), ilike(invoices.reference, pattern), ilike(contacts.name, pattern)));
-    }
-    const rows = await db.select({ invoice: invoices, contactName: contacts.name }).from(invoices)
-      .leftJoin(contacts, eq(contacts.id, invoices.contactId))
-      .where(and(...where))
-      .orderBy(desc(invoices.createdAt), desc(invoices.id))
-      .limit(limit);
-    const jobs = await jobsByInvoice(db, organisationId, rows.map((r) => r.invoice.id));
-    const counted = await db.select({ status: invoices.status, n: sql`count(*)::int` }).from(invoices)
+    // Each tab switch runs this, so the independent reads run side by side;
+    // only the to-check, ready and problem lists wait on the draft checks.
+    const system = accounting();
+    const checking = invoiceViews(db, organisationId, { accounting: system });
+    const counting = db.select({ status: invoices.status, n: sql`count(*)::int` }).from(invoices)
       .where(eq(invoices.organisationId, organisationId)).groupBy(invoices.status);
+    const sendMode = system
+      ? Promise.all([sendModeSummary(db, organisationId), system.capabilities.sendStatus({ organisationId })])
+        .then(([summary, sendStatus]) => ({ ...summary, ...sendStatus }))
+      : null;
+    const listing = (async () => {
+      const views = VIEWS_OF_INVOICES.includes(status) ? await checking : null;
+      const where = [eq(invoices.organisationId, organisationId)];
+      const only = (ids) => (ids.length ? inArray(invoices.id, ids) : sql`false`);
+      if (status === 'to_check') where.push(only(views.toCheck));
+      else if (status === 'ready') where.push(only(views.ready));
+      else if (status === 'problem') where.push(only([...views.problems.keys()]));
+      else if (status) where.push(eq(invoices.status, status));
+      if (q) {
+        const pattern = containing(q);
+        where.push(or(ilike(invoices.number, pattern), ilike(invoices.reference, pattern), ilike(contacts.name, pattern)));
+      }
+      const rows = await db.select({ invoice: invoices, contactName: contacts.name }).from(invoices)
+        .leftJoin(contacts, eq(contacts.id, invoices.contactId))
+        .where(and(...where))
+        .orderBy(desc(invoices.createdAt), desc(invoices.id))
+        .limit(limit);
+      return { rows, jobs: await jobsByInvoice(db, organisationId, rows.map((r) => r.invoice.id)) };
+    })();
+    const [views, counted, { rows, jobs }, mode] = await Promise.all([checking, counting, listing, sendMode]);
     const counts = Object.fromEntries(INVOICE_STATUSES.map((s) => [s, 0]));
     for (const { status: s, n } of counted) counts[s] = n;
     counts.to_check = views.toCheck.length;
@@ -324,8 +337,8 @@ export function createInvoicingRouter({
         problems: views.problems.get(invoice.id) ?? [],
       })),
       counts,
-      sendsTo: accounting()?.name ?? null,
-      sendMode: accounting() ? { ...(await sendModeSummary(db, organisationId)), ...(await accounting().capabilities.sendStatus({ organisationId })) } : null,
+      sendsTo: system?.name ?? null,
+      sendMode: mode,
     });
   }));
 
@@ -355,7 +368,9 @@ export function createInvoicingRouter({
     const organisationId = await organisationOf(req);
     const issueDate = optionalDate(req.body?.issueDate, 'issueDate') ?? today();
     const ids = req.body?.invoiceIds === undefined ? null : invoiceIdsOf(req.body);
-    const result = await sendAllReady(db, organisationId, { accounting: accounting(), personId: req.person.id, issueDate, invoiceIds: ids });
+    // Read before act (issue #141) reads each old job from the work system that can.
+    const reader = work().find((a) => typeof a.capabilities.readWorkItem === 'function') ?? null;
+    const result = await sendAllReady(db, organisationId, { accounting: accounting(), work: reader, personId: req.person.id, issueDate, invoiceIds: ids });
     log.info?.(`[invoicing] organisation ${organisationId}: person ${req.person.id} sent all ready: ${JSON.stringify(result)}`);
     res.json({ ok: true, ...result });
   }));
@@ -495,15 +510,33 @@ export function createInvoicingRouter({
     const organisationId = await organisationOf(req);
     // With no accounting system connected, Flow's own records are the check.
     const liveCheck = liveCheckFor(organisationId) ?? null;
-    const [obligation] = await db.select().from(billingObligations)
+    let [obligation] = await db.select().from(billingObligations)
       .where(and(eq(billingObligations.organisationId, organisationId), eq(billingObligations.id, obligationId)));
+    const source = obligation ? work().find((a) => a.id === obligation.sourceSystem) ?? null : null;
+    if (obligation) {
+      // Read before act (issue #141): an old job report is read again first.
+      const read = (await readBeforeAct(db, organisationId, [obligation], { work: source, actor: `person:${req.person.id}` })).get(obligation.id);
+      if (read.outcome === 'waiting' || read.outcome === 'review') {
+        throw new FlowError('not_ready', 'the draft invoice was refused', { reasons: [read.reason ?? read.obligation.holdReason ?? 'the job needs a look'] });
+      }
+      obligation = read.obligation;
+    }
     const { referenceTemplate: template } = await readInvoicingSettings(db, organisationId);
-    const reference = obligation ? await jobReference(db, organisationId, obligation, { template, work: work().find((a) => a.id === obligation.sourceSystem) ?? null }) : null;
+    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) });
   }));
 
+  // "Use new lines": the job changed in the work system after its draft was
+  // made, and only there. Flow changes its own draft; no other system.
+  router.post('/jobs/:id/use-new-lines', ...manager, handle(log, async (req, res) => {
+    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) });
+  }));
+
   router.post('/jobs/:id/ready', ...signedIn, handle(log, async (req, res) => {
     const obligationId = pathId(req.params.id, 'job');
     const organisationId = await organisationOf(req);

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,9 +1,12 @@
 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';
 import { integrationAlertsSource, invoiceProblemsSource, priceDifferencesSource } from './core/alerts.js';
+import { reconcileHealth } from './core/reconcile.js';
 import { appliedMigrationCounts } from './db/doctor.js';
 import { deployedBuildStatus } from './deployed-build.js';
 import { integrationsHealth } from './integrations/health.js';
@@ -34,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,
@@ -48,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;
@@ -72,6 +79,9 @@ export function createApp({
         .then((migrations) => ({ migrations }), () => null);
     }
     if (integrations) body.integrations = await integrationsHealth(integrations);
+    // The daily reconcile's last run (server/core/reconcile.js): counts only.
+    // A difference does not fail the health check.
+    if (databaseOk && database.db) body.reconcile = await reconcileHealth(database.db).catch(() => null);
     res.status(ok ? 200 : 503).json(body);
   });
 
@@ -132,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({