@arcforgelabs/flow 2026.10.32 → 2026.10.33

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

@@ -120,6 +120,13 @@
       "when": 1792456270558,
       "tag": "0016_invoice_reference",
       "breakpoints": true
+    },
+    {
+      "idx": 17,
+      "version": "7",
+      "when": 1792458167234,
+      "tag": "0017_sync_basis",
+      "breakpoints": true
     }
   ]
 }

package/server/db/schema.js

@@ -250,6 +250,9 @@ export const billingObligations = pgTable('billing_obligations', {
   holdReason: text('hold_reason'),
   // The Flow invoice made for this job.
   invoiceId: uuid('invoice_id'),
+  // The job facts the invoice was built from: the merge base for the
+  // three-way compare when the job changes later (server/core/ledger.js).
+  draftBasis: jsonb('draft_basis'),
   // What the accounting system reported, how it matched, and when Flow checked.
   accountingState: text('accounting_state').notNull().default('unknown'),
   accountingRef: text('accounting_ref'),

package/server/index.js

@@ -11,6 +11,7 @@ import {
 } from './import/at-start.js';
 import { createMonitoredLog } from './core/monitoring.js';
 import { createPipelineWorker } from './core/pipeline.js';
+import { createReconcileWorker } from './core/reconcile.js';
 import { createSendWorker } from './core/sending.js';
 import { resolveSecretsKey } from './core/secrets.js';
 import { adapters as shippedAdapters } from './integrations/adapters.js';
@@ -97,6 +98,10 @@ console.log(`[integrations] on: ${integrationsOn.join(', ') || 'none'}; secrets
 if (process.env.FLOW_PIPELINE !== 'off') {
   createPipelineWorker({ db: database.db, integrations, log }).start();
 }
+// The daily reconcile (server/core/reconcile.js) compares Flow's own copies
+// and opens a review item for a day that does not agree. It never calls or
+// writes to another system.
+createReconcileWorker({ 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();

package/server/integrations/port.js

@@ -11,6 +11,7 @@ import { isMissingTable, migrateAdapterSchema } from './schema.js';
 
 export const CAPABILITIES = Object.freeze([
   'pullWorkItems', // billable work since a cursor (Seazona: completed cases)
+  'readWorkItem', // { state: read | withdrawn | unavailable }: one job read from the work system now, as pullWorkItems gives it (read before act, server/core/read-before-act.js)
   'pullHistoryJobs', // past work from a history import, as ledger jobs marked historical (Seazona: its API backfill)
   '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)
@@ -20,11 +21,13 @@ 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)
+  'billableJobs', // billable jobs by day from the work system's copy in Flow, for the daily reconcile; never a live call
   'jobReferenceFields', // { patient }: the fields a job gives the invoice Reference (server/core/references.js)
   'listWork', // the work system's jobs from its copy in Flow, open and lately finished, for the Jobs board
   'jobIssues', // open issues the integration holds for jobs, by job ref: a short phrase and the page where a person fixes it
   '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
+  'readChanges', // { state: fresh | read | unavailable }: the accounting system's latest changes into its copy now, just before Flow drafts or sends (read before act)
   'listPriceItems', // the system's own price list from its copy in Flow, for the price list's links and check; never a live call
   'health', // connection state for Settings
   'alerts', // what only a person can clear (a refused sign-in, stopped calls), for the Integrations page; reads Flow's data only

package/server/integrations/seazona/act.js

@@ -0,0 +1,48 @@
+import { readBillableOrder } from './feed.js';
+import { readOrder } from './lanes.js';
+
+// Read before act (issue #141). Just before Flow drafts or sends from a job
+// whose report is old, it reads that one order from Seazona: one
+// GET orders/{id}, through the call guard, stored through the mirror like
+// any lane read. The answer is the order as the feed gives it:
+//
+//   { state: 'read', item }               billable; `item` is a feed item
+//   { state: 'withdrawn', ledgerWithdrawn, reason }
+//                                          deleted in Seazona, or no longer
+//                                          billable
+//   { state: 'unavailable', reason }      the read failed or calls are stopped
+//
+// The day's counts are kept in memory for /health; a restart starts them again.
+export function createActReader({ now }) {
+  let tally = null;
+  function count(key) {
+    const day = new Date(Number(now())).toISOString().slice(0, 10);
+    if (tally?.day !== day) tally = { day, reads: 0, changed: 0, withdrawn: 0, unavailable: 0 };
+    tally[key] += 1;
+  }
+  const unavailable = (reason) => {
+    count('unavailable');
+    return { state: 'unavailable', reason };
+  };
+
+  async function read({ db, client, settings }, orderId) {
+    count('reads');
+    let result;
+    try {
+      result = await readOrder({ db, client, sync: settings.sync, at: new Date(Number(now())) }, orderId, { known: true });
+    } catch (error) {
+      return unavailable(error?.message || 'the read failed');
+    }
+    if (result.outcome === 'failed') return unavailable(result.failure?.error || 'the read failed');
+    if (result.summary?.changed || result.summary?.created) count('changed');
+    const entry = await readBillableOrder(db, orderId);
+    if (!entry) return unavailable('Flow has no copy of the order');
+    if (entry.withdrawn) {
+      count('withdrawn');
+      return { state: 'withdrawn', ledgerWithdrawn: entry.withdrawn.ledgerWithdrawn, reason: entry.withdrawn.reason };
+    }
+    return { state: 'read', item: entry.item };
+  }
+
+  return { read, status: () => (tally ? { ...tally } : null) };
+}

package/server/integrations/seazona/feed.js

@@ -1,5 +1,5 @@
 import { and, desc, eq, gte, isNull, or, sql } from 'drizzle-orm';
-import { ledgerLinesFor, toLedgerHold, toLedgerJob } from './ledger.js';
+import { ledgerLinesFor, toLedgerJob, toLedgerWithdrawn } from './ledger.js';
 import { isFinalStatus, orderStatusLabel, parseSeazonaDate } from './map.js';
 import { seazonaClients, seazonaInvoices, seazonaOrders, seazonaReference } from './schema.js';
 
@@ -36,11 +36,9 @@ function encodeCursor(at, id) {
   return Buffer.from(JSON.stringify({ at, id })).toString('base64url');
 }
 
-export async function readBillableWork(db, { cursor = null, limit = 200 } = {}) {
-  const after = decodeCursor(cursor);
-  const changedAt = sql`greatest(${seazonaOrders.lastChangedAt}, coalesce(${seazonaInvoices.lastChangedAt}, ${seazonaOrders.lastChangedAt}), date_trunc(${SEEN_STEP}, ${seazonaOrders.lastSyncedAt}))`;
-  const pageSize = Math.max(1, Math.min(1000, limit));
-  const rows = await db.select({
+// One order, its invoice and its client, as the feed reads them.
+function feedQuery(db, changedAt) {
+  return db.select({
     order: seazonaOrders,
     invoice: seazonaInvoices,
     client: { accountNumber: seazonaClients.accountNumber, company: seazonaClients.company, email: seazonaClients.email },
@@ -50,56 +48,70 @@ export async function readBillableWork(db, { cursor = null, limit = 200 } = {})
   })
     .from(seazonaOrders)
     .leftJoin(seazonaInvoices, eq(seazonaInvoices.invoiceNumber, seazonaOrders.invoiceNumber))
-    .leftJoin(seazonaClients, eq(seazonaClients.id, seazonaOrders.clientId))
+    .leftJoin(seazonaClients, eq(seazonaClients.id, seazonaOrders.clientId));
+}
+
+// A feed row as an item, or as a withdrawn entry when it is not billable.
+function toFeedEntry({ order, invoice, client, invoiceOrderCount }) {
+  const billable = !order.deletedInSourceAt && BILLABLE.test(order.status ?? '');
+  if (!billable) {
+    const entry = {
+      sourceId: order.id,
+      status: orderStatusLabel(order),
+      reason: order.deletedInSourceAt ? 'deleted_in_seazona' : 'not_billable',
+    };
+    const syncedAt = order.lastSyncedAt?.toISOString() ?? null;
+    return { withdrawn: { ...entry, ledgerWithdrawn: toLedgerWithdrawn({ ...entry, syncedAt }) } };
+  }
+  const item = {
+    source: 'seazona',
+    sourceId: order.id,
+    invoiceNumber: order.invoiceNumber,
+    status: order.status,
+    shipped: SHIPPED.test(order.status ?? ''),
+    clientId: order.clientId,
+    company: order.company,
+    doctorName: order.doctorName,
+    orderedOn: parseSeazonaDate(order.orderedText),
+    dueOn: parseSeazonaDate(order.dueText),
+    lines: order.lines,
+    subtotalCents: order.subtotalCents,
+    patientReference: order.patientReference,
+    syncedAt: order.lastSyncedAt.toISOString(),
+    invoice: invoice ? {
+      invoiceNumber: invoice.invoiceNumber,
+      status: invoice.status,
+      accountNumber: invoice.accountNumber,
+      invoiceDate: parseSeazonaDate(invoice.invoiceDateText),
+      dueDate: parseSeazonaDate(invoice.dueText),
+      lines: invoice.lines,
+      subtotalCents: invoice.subtotalCents,
+      taxCents: invoice.taxCents,
+      totalCents: invoice.totalCents,
+      discountCents: invoice.discountCents,
+      patientReference: invoice.patientReference,
+    } : null,
+    client: client?.accountNumber || client?.company || client?.email ? client : null,
+    invoiceOrderCount: order.invoiceNumber ? Number(invoiceOrderCount) : 0,
+  };
+  return { item: { ...item, linesFrom: ledgerLinesFor(item).linesFrom, ledgerJob: toLedgerJob(item) } };
+}
+
+export async function readBillableWork(db, { cursor = null, limit = 200 } = {}) {
+  const after = decodeCursor(cursor);
+  const changedAt = sql`greatest(${seazonaOrders.lastChangedAt}, coalesce(${seazonaInvoices.lastChangedAt}, ${seazonaOrders.lastChangedAt}), date_trunc(${SEEN_STEP}, ${seazonaOrders.lastSyncedAt}))`;
+  const pageSize = Math.max(1, Math.min(1000, limit));
+  const rows = await feedQuery(db, changedAt)
     .where(after ? sql`(${changedAt}, ${seazonaOrders.id}) > (${after.at}::timestamptz, ${after.id})` : undefined)
     .orderBy(changedAt, seazonaOrders.id)
     .limit(pageSize);
 
   const items = [];
   const withdrawn = [];
-  for (const { order, invoice, client, invoiceOrderCount } of rows) {
-    const billable = !order.deletedInSourceAt && BILLABLE.test(order.status ?? '');
-    if (!billable) {
-      const entry = {
-        sourceId: order.id,
-        status: orderStatusLabel(order),
-        reason: order.deletedInSourceAt ? 'deleted_in_seazona' : 'not_billable',
-      };
-      withdrawn.push({ ...entry, ledgerHold: toLedgerHold(entry) });
-      continue;
-    }
-    const item = {
-      source: 'seazona',
-      sourceId: order.id,
-      invoiceNumber: order.invoiceNumber,
-      status: order.status,
-      shipped: SHIPPED.test(order.status ?? ''),
-      clientId: order.clientId,
-      company: order.company,
-      doctorName: order.doctorName,
-      orderedOn: parseSeazonaDate(order.orderedText),
-      dueOn: parseSeazonaDate(order.dueText),
-      lines: order.lines,
-      subtotalCents: order.subtotalCents,
-      patientReference: order.patientReference,
-      syncedAt: order.lastSyncedAt.toISOString(),
-      invoice: invoice ? {
-        invoiceNumber: invoice.invoiceNumber,
-        status: invoice.status,
-        accountNumber: invoice.accountNumber,
-        invoiceDate: parseSeazonaDate(invoice.invoiceDateText),
-        dueDate: parseSeazonaDate(invoice.dueText),
-        lines: invoice.lines,
-        subtotalCents: invoice.subtotalCents,
-        taxCents: invoice.taxCents,
-        totalCents: invoice.totalCents,
-        discountCents: invoice.discountCents,
-        patientReference: invoice.patientReference,
-      } : null,
-      client: client?.accountNumber || client?.company || client?.email ? client : null,
-      invoiceOrderCount: order.invoiceNumber ? Number(invoiceOrderCount) : 0,
-    };
-    items.push({ ...item, linesFrom: ledgerLinesFor(item).linesFrom, ledgerJob: toLedgerJob(item) });
+  for (const row of rows) {
+    const entry = toFeedEntry(row);
+    if (entry.item) items.push(entry.item);
+    else withdrawn.push(entry.withdrawn);
   }
   const lastRow = rows.at(-1);
   return {
@@ -110,6 +122,14 @@ export async function readBillableWork(db, { cursor = null, limit = 200 } = {})
   };
 }
 
+// One order as the feed gives it (issue #141, read before act): `{ item }`
+// when it is billable, `{ withdrawn }` when it is not, or null when Flow's
+// copy does not have it.
+export async function readBillableOrder(db, orderId) {
+  const [row] = await feedQuery(db, seazonaOrders.lastChangedAt).where(eq(seazonaOrders.id, orderId));
+  return row ? toFeedEntry(row) : null;
+}
+
 // Seazona clients, by id and the company name an invoice bills. A client
 // 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

package/server/integrations/seazona/governor.js

@@ -68,6 +68,30 @@ export class SeazonaCallsStopped extends CallsStopped {
   }
 }
 
+// A request path with its record ids taken out, so /health can say which
+// calls failed and never names a record: /v1/orders/5591234 is
+// /v1/orders/:id. A name is lowercase words joined by hyphens, or a version.
+export function pathShape(path) {
+  const name = /^(v\d+|[a-z]+(-[a-z]+)*)$/;
+  return `/${String(path || '').split('/').filter(Boolean).map((part) => (name.test(part) ? part : ':id')).join('/')}`;
+}
+
+// Issue #144: the last day's failed calls split into faults (what the call
+// guard counts, and a vendor may count against the API client) and 404s
+// (a record that is gone), and the top groups by path shape, status and
+// kind.
+function failureKinds(day, top = 10) {
+  const groups = new Map();
+  for (const row of day.failures) {
+    const group = { path: pathShape(row.path), statusCode: row.statusCode ?? null, failureKind: row.failureKind ?? null };
+    const key = JSON.stringify(group);
+    groups.set(key, { ...group, requests: (groups.get(key)?.requests ?? 0) + row.requests });
+  }
+  const sorted = [...groups.values()].sort((a, b) => b.requests - a.requests).slice(0, top);
+  // Every failed call is a fault but a 404 (countsAsFailure, call-guard.js).
+  return { faults: day.failed - day.notFound, notFound: day.notFound, failures: sorted };
+}
+
 export function createSeazonaGovernor({
   db,
   clientKey,
@@ -171,7 +195,7 @@ export function createSeazonaGovernor({
     const calls = await guard.status(key);
     const [{ lastMinute }] = await db.select({ lastMinute: count() }).from(seazonaApiRequests)
       .where(and(eq(seazonaApiRequests.clientKey, key), gte(seazonaApiRequests.admittedAt, new Date(nowMs - WINDOW_MS))));
-    const day = await summarise({ from: new Date(nowMs - 24 * 60 * 60_000), to: new Date(nowMs) });
+    const day = await summarise({ from: new Date(nowMs - 24 * 60 * 60_000), to: new Date(nowMs), topFailures: 500 });
     const cooldownUntil = state && state.cooldownUntil.getTime() > nowMs ? state.cooldownUntil.toISOString() : null;
     return {
       limitPerMinute: limit,
@@ -184,7 +208,7 @@ export function createSeazonaGovernor({
       haltedAt: calls.haltedAt,
       failedToday: calls.failedToday,
       dailyFailureBudget: calls.dailyFailureBudget,
-      lastDay: { requests: day.requests, failed: day.failed, rateLimited: day.rateLimited, retries: day.retries },
+      lastDay: { requests: day.requests, failed: day.failed, rateLimited: day.rateLimited, retries: day.retries, ...failureKinds(day) },
     };
   }
 
@@ -201,6 +225,7 @@ export function createSeazonaGovernor({
       failed: sql`count(*) filter (where ${seazonaApiRequests.statusCode} is null or ${seazonaApiRequests.statusCode} >= 400)`,
       rateLimited: sql`count(*) filter (where ${seazonaApiRequests.statusCode} = 429)`,
       retries: sql`count(*) filter (where ${seazonaApiRequests.isRetry})`,
+      notFound: sql`count(*) filter (where ${seazonaApiRequests.statusCode} = 404)`,
     }).from(seazonaApiRequests).where(range);
     const failures = await db.select({
       path: seazonaApiRequests.requestPath,
@@ -219,6 +244,7 @@ export function createSeazonaGovernor({
       failed: Number(totals.failed),
       rateLimited: Number(totals.rateLimited),
       retries: Number(totals.retries),
+      notFound: Number(totals.notFound),
       failures: failures.map((row) => ({ ...row, requests: Number(row.requests) })),
     };
   }

package/server/integrations/seazona/index.js

@@ -1,12 +1,15 @@
 import { guardAlerts } from '../call-guard.js';
+import { createActReader } from './act.js';
 import { createSeazonaClient } from './client.js';
 import { listClients, listProducts, listWork, readBillableWork } from './feed.js';
 import { historyJobIssues, historySummary, readHistoryWork } from './history/index.js';
 import { readSeazonaSyncHealth, runSeazonaSync } from './lanes.js';
+import { readBillableJobs } from './reconcile.js';
 import { SEAZONA_CALL_GUARD } from './governor.js';
 import { createSeazonaRouter } from './routes.js';
 import { orderPatient } from './patients.js';
 import { createSeazonaScheduler } from './scheduler.js';
+import { readSweepHealth } from './sweep.js';
 import { resetFailedLanes, resetStoppedLanes } from './store.js';
 import { describeSeazonaSettings, resolveSeazonaSettings } from './settings.js';
 import { seazonaSchema } from './tables.js';
@@ -49,8 +52,21 @@ export const SEAZONA_SETUP = {
   ],
 };
 
+// What a person reads for each lane: the Seazona records it copies.
+const READ_NAMES = {
+  invoices: 'invoices',
+  orders_recent: 'new orders',
+  orders_active: 'open orders',
+  clients: 'practices',
+  products: 'products',
+  users: 'lab users',
+  history: 'past orders',
+};
+const readNames = (lanes) => lanes.map((lane) => READ_NAMES[lane.lane] ?? lane.lane).join(', ');
+
 export function createSeazonaAdapter({ env = null, fetchImpl = null, now = Date.now, timers } = {}) {
   let runtime = null; // { settings, db, client, scheduler }
+  const actReader = createActReader({ now });
 
   function current() {
     if (!runtime) throw new Error('The Seazona adapter has not started');
@@ -107,13 +123,17 @@ export function createSeazonaAdapter({ env = null, fetchImpl = null, now = Date.
         if (!runtime) return { ok: false, reason: 'not_started', ...describeSeazonaSettings(null) };
         const { settings, db, client, scheduler } = runtime;
         const sync = await readSeazonaSyncHealth(db, settings, { now });
+        const schedulerStatus = scheduler ? scheduler.status() : null;
         return {
-          ok: sync.ok,
+          ok: sync.ok && !schedulerStatus?.stuckSince,
           ...describeSeazonaSettings(settings),
-          scheduler: scheduler ? scheduler.status() : null,
+          scheduler: schedulerStatus,
           governor: await client.governor.status(),
           ...sync,
+          // Issue #141: today's reads before a draft or a send.
+          readsBeforeAct: actReader.status(),
           history: await historySummary(db),
+          sweep: await readSweepHealth(db, settings, { now }),
         };
       },
 
@@ -122,7 +142,31 @@ export function createSeazonaAdapter({ env = null, fetchImpl = null, now = Date.
       // a person saves the settings. Reads Flow's database only.
       async alerts() {
         if (!runtime?.client.governor) return [];
-        return guardAlerts('Seazona', await runtime.client.governor.status(), { fix: 'Check the API client in the Seazona settings, then save them.' });
+        const status = await runtime.client.governor.status();
+        const alerts = guardAlerts('Seazona', status, { fix: 'Check the API client in the Seazona settings, then save them.' });
+        // Issue #143: what the lanes cannot fix by themselves. A refused API
+        // client already has its own alert above, so it stops no lane here.
+        if (!runtime.settings.scheduled) return alerts;
+        const { lanes } = await readSeazonaSyncHealth(runtime.db, runtime.settings, { now });
+        const stopped = status.haltedReason ? [] : lanes.filter((lane) => lane.status === 'stopped');
+        if (stopped.length) {
+          alerts.push({
+            id: 'reads-stopped',
+            tone: 'danger',
+            title: `Seazona refused Flow's request for ${readNames(stopped)}. Flow stopped reading them. Check the Seazona settings, then save them.`,
+            members: stopped.map((lane) => `${lane.lane}:${lane.lastAttemptAt ?? ''}`),
+          });
+        }
+        const stale = lanes.filter((lane) => lane.stale && lane.status !== 'stopped');
+        if (stale.length) {
+          alerts.push({
+            id: 'reads-late',
+            tone: 'warn',
+            title: `Flow has not read ${readNames(stale)} from Seazona on time. Jobs and invoices may show old Seazona data.`,
+            members: stale.map((lane) => `${lane.lane}:${lane.lastSuccessAt ?? ''}`),
+          });
+        }
+        return alerts;
       },
 
       // Billable work since a cursor: complete and shipped orders that
@@ -133,12 +177,25 @@ export function createSeazonaAdapter({ env = null, fetchImpl = null, now = Date.
         return readBillableWork(current().db, { cursor, ...options });
       },
 
+      // Read before act (issue #141): reads one order from Seazona now, and
+      // answers it as the feed would (act.js). The only capability here that
+      // calls Seazona on a person's or an automation's behalf.
+      async readWorkItem({ sourceJobRef }) {
+        return actReader.read(current(), sourceJobRef);
+      },
+
       // Past work from the history import (docs/SEAZONA.md, "History
       // import"), as ledger jobs marked `historical`. Reads Flow's copy only.
       async pullHistoryJobs(cursor = null, options = {}) {
         return readHistoryWork(current().db, { cursor, ...options });
       },
 
+      // Billable jobs by day, for the daily reconcile
+      // (server/core/reconcile.js). Reads Flow's copy only.
+      async billableJobs({ from = null, to = null } = {}) {
+        return readBillableJobs(current().db, { from, to });
+      },
+
       // Seazona clients by id and company name, for the identity map. Reads
       // Flow's copy only.
       async listCustomers() {

package/server/integrations/seazona/lanes.js

@@ -11,6 +11,7 @@ import {
 } from './map.js';
 import { runHistoryBackfill } from './history/backfill.js';
 import { seazonaOrders } from './schema.js';
+import { runSweep } from './sweep.js';
 import {
   claimLane,
   clearOrderFailure,
@@ -22,6 +23,8 @@ import {
   readQuarantinedOrders,
   readQuarantinedRecordCounts,
   readQuarantinedRecords,
+  readRecordRereadCounts,
+  readRecordsDueForReread,
   recordOrderFailure,
   recordRecordFailure,
   selectActiveOrders,
@@ -41,6 +44,8 @@ import {
 //   users          the lab user list, daily
 //   history        past orders, a few calls per run, only while a person
 //                  has started a backfill (history/backfill.js)
+//   sweep          whole lists again, slowly, for what the others missed
+//                  (issue #126, sweep.js)
 //
 // Issue #12 holds for every order read: a 404 marks the order deleted in
 // Seazona, an empty answer is a failure, each failure is recorded per order
@@ -58,7 +63,7 @@ import {
 // only after a person saves the settings or Flow restarts on a new release.
 // Calls the governor stopped (SeazonaCallsStopped) wait out its pause.
 
-export const LANES = Object.freeze(['invoices', 'orders_recent', 'orders_active', 'clients', 'products', 'users', 'history']);
+export const LANES = Object.freeze(['invoices', 'orders_recent', 'orders_active', 'clients', 'products', 'users', 'history', 'sweep']);
 
 const DAY_MS = 24 * 60 * 60_000;
 const MAX_REPORTED = 25;
@@ -237,6 +242,7 @@ async function syncListWithDetail(ctx, { mirror, what, items, keyOf, idOf, signa
           at,
           quarantineFailures: sync.orderQuarantineFailures,
           quarantineMs: sync.orderQuarantineMs,
+          detailId: id,
         });
         if (recorded.quarantinedUntil) newlyQuarantined += 1;
         failures.push({ id: key, ...failure, ...recorded });
@@ -257,6 +263,52 @@ async function syncListWithDetail(ctx, { mirror, what, items, keyOf, idOf, signa
   return { summary, detailReads, listCount: items.length, failureDetails, anyFailed, newlyQuarantined, quarantined: skipped.length };
 }
 
+// Issue #142: a quarantined invoice or client is in a later list only if it
+// changes again, so when its wait ends the lane reads its detail by id. A
+// success stores it and clears the failure; a 404 clears the failure (the
+// record is gone, issue #126); a failure quarantines it again, with no new
+// report. Each read goes through the call guard like any other.
+async function rereadReleased(ctx, { mirror, what, detailPath, map }) {
+  const { db, client, sync, at } = ctx;
+  const due = sync.recordRereadsPerRun ? await readRecordsDueForReread(db, mirror, { at, limit: sync.recordRereadsPerRun }) : [];
+  const result = { summary: { created: 0, changed: 0, unchanged: 0 }, detailReads: 0, reread: 0, gone: 0, failed: 0 };
+  for (const row of due) {
+    result.detailReads += 1;
+    try {
+      const detail = await client.get(detailPath(row.detailId));
+      if (!detail || typeof detail !== 'object' || Array.isArray(detail)) throw emptyResponse(`${what} ${row.recordKey}`);
+      addSummary(result.summary, await upsertRecords(db, mirror, [map(detail)], { at }));
+      await clearRecordFailures(db, mirror, [row.recordKey]);
+      result.reread += 1;
+    } catch (error) {
+      if (isLaneLevel(error)) throw error;
+      if (error?.statusCode === 404) {
+        await clearRecordFailures(db, mirror, [row.recordKey]);
+        result.gone += 1;
+        continue;
+      }
+      await recordRecordFailure(db, mirror, row.recordKey, describeReadFailure(error), {
+        at,
+        quarantineFailures: sync.orderQuarantineFailures,
+        quarantineMs: sync.orderQuarantineMs,
+      });
+      result.failed += 1;
+    }
+  }
+  return result;
+}
+
+// Adds the re-reads to a lane's result.
+function withRereads(result, reread) {
+  if (!reread.detailReads) return result;
+  addSummary(result.summary, reread.summary);
+  return {
+    ...result,
+    detailReads: result.detailReads + reread.detailReads,
+    rereads: { attempted: reread.detailReads, read: reread.reread, gone: reread.gone, failed: reread.failed },
+  };
+}
+
 // Where the next changed-list read starts. A run that stopped inside a
 // window keeps the exact start of the next part (`cursor.since`); otherwise
 // the last finished run's start, less the overlap.
@@ -351,7 +403,13 @@ const laneRuns = {
     const { client, sync, at } = ctx;
     const firstSince = cursorSince(ctx, new Date(floorUtcDay(at.getTime()) - sync.invoiceLookbackDays * DAY_MS).toISOString());
     const mapOptions = { keepPatientReference: sync.keepPatientReference };
-    return walkChangedList(ctx, {
+    const reread = await rereadReleased(ctx, {
+      mirror: 'invoices',
+      what: 'invoice',
+      detailPath: (id) => `invoices/${encodeURIComponent(id)}`,
+      map: (detail) => mapInvoice({}, detail, mapOptions),
+    });
+    return withRereads(await walkChangedList(ctx, {
       what: 'invoice',
       firstSince,
       // The guide: on or after lastModified (inclusive).
@@ -367,7 +425,7 @@ const laneRuns = {
         detailPath: (id) => `invoices/${encodeURIComponent(id)}`,
         map: (item, detail) => mapInvoice(item, detail, mapOptions),
       }),
-    });
+    }), reread);
   },
 
   async orders_recent(ctx) {
@@ -485,10 +543,16 @@ const laneRuns = {
 
   async clients(ctx) {
     const { client } = ctx;
+    const reread = await rereadReleased(ctx, {
+      mirror: 'clients',
+      what: 'client',
+      detailPath: (id) => `clients/${encodeURIComponent(id)}`,
+      map: (detail) => mapClient({}, detail),
+    });
     // 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.
-    return walkChangedList(ctx, {
+    return withRereads(await walkChangedList(ctx, {
       what: 'client',
       firstSince: cursorSince(ctx, ''),
       // The guide says "modified after": step back a second so a row in the
@@ -505,10 +569,11 @@ const laneRuns = {
         detailPath: (id) => `clients/${encodeURIComponent(id)}`,
         map: (item, detail) => mapClient(item, detail),
       }),
-    });
+    }), reread);
   },
 
   history: (ctx) => runHistoryBackfill(ctx, { isLaneLevel, describeReadFailure, emptyResponse, LaneError }),
+  sweep: (ctx) => runSweep(ctx, { readOrder, isLaneLevel, describeReadFailure, emptyResponse, LaneError }),
   products: (ctx) => syncReference(ctx, 'products'),
   users: (ctx) => syncReference(ctx, 'users'),
 };
@@ -589,20 +654,27 @@ export async function runSeazonaSync(db, client, { settings, now = Date.now, onl
 // What /health shows for the sync: each lane's state, the failing and
 // quarantined orders by id and status, and how many orders are marked
 // deleted in Seazona. No patient data.
+//
+// Issue #143: a lane that ran before and has not succeeded within its
+// freshness limit (or two of its own cadences, if those are longer) is
+// stale, and a stale lane makes `ok` false like a failed one.
 export async function readSeazonaSyncHealth(db, settings, { now = Date.now } = {}) {
   const nowMs = Number(now());
   const states = await readLaneStates(db);
   const quarantinedOrders = await readQuarantinedOrders(db, { at: new Date(nowMs), limit: MAX_REPORTED });
   const [{ deleted }] = await db.select({ deleted: count() }).from(seazonaOrders).where(isNotNull(seazonaOrders.deletedInSourceAt));
   const quarantinedRecords = await readQuarantinedRecordCounts(db, { at: new Date(nowMs) });
+  const rereadDue = await readRecordRereadCounts(db, { at: new Date(nowMs) });
   const lanes = LANES.map((lane) => {
     const state = states.get(lane);
-    const { freshnessMs } = settings.sync.lanes[lane];
+    const { freshnessMs, cadenceMs } = settings.sync.lanes[lane];
+    const staleAfterMs = Math.max(freshnessMs, 2 * cadenceMs);
     const ageMs = state?.lastSuccessAt ? Math.max(0, nowMs - state.lastSuccessAt.getTime()) : null;
     return {
       lane,
       status: state?.status ?? 'never_run',
-      fresh: ageMs !== null && ageMs <= freshnessMs,
+      fresh: ageMs !== null && ageMs <= staleAfterMs,
+      stale: ageMs !== null && ageMs > staleAfterMs,
       ageMs,
       lastSuccessAt: state?.lastSuccessAt?.toISOString() ?? null,
       lastAttemptAt: state?.lastAttemptAt?.toISOString() ?? null,
@@ -613,10 +685,11 @@ export async function readSeazonaSyncHealth(db, settings, { now = Date.now } = {
       failureDetails: state?.failureDetails ?? null,
       ...(lane === 'orders_active' ? { quarantinedOrders } : {}),
       ...(quarantinedRecords[lane] ? { quarantinedRecords: quarantinedRecords[lane] } : {}),
+      ...(rereadDue[lane] ? { rereadDue: rereadDue[lane] } : {}),
     };
   });
   return {
-    ok: lanes.every((lane) => !['failed', 'held', 'stopped'].includes(lane.status)),
+    ok: lanes.every((lane) => !lane.stale && !['failed', 'held', 'stopped'].includes(lane.status)),
     lanes,
     deletedOrders: Number(deleted),
   };