@arcforgelabs/flow 2026.11.5 → 2026.11.7

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

@@ -204,6 +204,13 @@
       "when": 1794456064675,
       "tag": "0028_sharp_power_pack",
       "breakpoints": true
+    },
+    {
+      "idx": 29,
+      "version": "7",
+      "when": 1794463202822,
+      "tag": "0029_job_remake",
+      "breakpoints": true
     }
   ]
 }

package/server/db/schema.js

@@ -253,6 +253,9 @@ export const billingObligations = pgTable('billing_obligations', {
   // The work system's status for the job, as it reported it (for example
   // "Shipped"). The draft rules read it.
   sourceStatus: text('source_status'),
+  // The work system marks the job a remake (Seazona's remake flag): the
+  // invoice rule field `remake` reads it.
+  remake: boolean('remake').notNull().default(false),
   // Flow's own stage: the job is ready to invoice, since when and by whom (a
   // person, or an automation such as one that reads the work system status).
   readyAt: timestamp('ready_at', { withTimezone: true }),

package/server/integrations/port.js

@@ -37,7 +37,10 @@ export const CAPABILITIES = Object.freeze([
   'createCustomer', // { organisationId, contactId, actor }: create the system's customer from the Flow contact. Answers { outcome, contact }. Xero, when Create missing clients is on.
   '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)
+  'itemMatches', // { organisationId, codes } -> the Flow price codes that send as an item the system sells (Xero: linked item, else same code), from its copy; null while not connected or its item list was never read; never a live call
   'listPriceItems', // the system's own price list from its copy in Flow, for the price list's links and check; never a live call
+  'syncNow', // { asked } -> { state: started | running | read | off | unavailable, reason?, changed? }: a person's Sync now; read the system's latest changes into its copy now, inside its call guard. off: its "Include in Sync now" setting is off and `asked` (a person's Sync for this integration alone) is false (server/core/sync-now.js)
+  'syncNowStatus', // {} -> { included, running, lastAt, ok }: for the Sync now button; reads Flow's data only
   '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
   'captureError', // an error Flow logged, sent to the installation's own error service (Sentry)

package/server/integrations/seazona/feed.js

@@ -77,6 +77,7 @@ function toFeedEntry({ order, invoice, client, invoiceOrderCount }) {
     lines: order.lines,
     subtotalCents: order.subtotalCents,
     patientReference: order.patientReference,
+    remake: order.remake === true,
     syncedAt: order.lastSyncedAt.toISOString(),
     invoice: invoice ? {
       invoiceNumber: invoice.invoiceNumber,

package/server/integrations/seazona/history/index.js

@@ -495,12 +495,13 @@ export async function readHistoryWork(db, { cursor = null, limit = 200 } = {}) {
   }
   const pageSize = Math.max(1, Math.min(1000, limit));
   const changedAt = sql`to_char(${seazonaHistoryJobs.lastChangedAt} at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"')`;
-  const rows = await db.select({ job: seazonaHistoryJobs, changedAt })
+  const rows = await db.select({ job: seazonaHistoryJobs, changedAt, remake: seazonaOrders.remake })
     .from(seazonaHistoryJobs)
+    .leftJoin(seazonaOrders, eq(seazonaOrders.id, seazonaHistoryJobs.mirrorOrderId))
     .where(after ? sql`(${seazonaHistoryJobs.lastChangedAt}, ${seazonaHistoryJobs.jobKey}) > (${after.at}::timestamptz, ${after.key})` : undefined)
     .orderBy(seazonaHistoryJobs.lastChangedAt, seazonaHistoryJobs.jobKey)
     .limit(pageSize);
-  const items = rows.map(({ job }) => {
+  const items = rows.map(({ job, remake }) => {
     const sourceJobRef = job.mirrorOrderId ?? job.caseRef ?? `history:${job.jobKey}`;
     return {
       source: 'seazona',
@@ -518,6 +519,8 @@ export async function readHistoryWork(db, { cursor = null, limit = 200 } = {}) {
         shippedOn: job.shippedDate,
         jobDate: job.jobDate ?? job.dueDate ?? job.shippedDate,
         sourceStatus: job.status,
+        // The order's remake flag, from Flow's copy of the order.
+        remake: remake === true,
         lines: (job.lines ?? []).map(ledgerLine),
         // The CSV reports a total, but no invoice tax allocation.
         sourceTotals: job.totalCents == null ? null : { totalCents: job.totalCents },

package/server/integrations/seazona/index.js

@@ -53,10 +53,15 @@ export const SEAZONA_SETUP = {
     { name: 'SEAZONA_API_CLIENT_SECRET', label: 'Client secret', secret: true, help: 'Stored encrypted. Flow never shows it again.' },
     { name: 'SEAZONA_ORDER_URL', label: 'Order address', kind: 'url', help: 'Optional. Open any order in Seazona and paste its address here, or write {ref} where the order id goes. Stage moves on the Jobs board and Open in Seazona use it.' },
     { name: 'SEAZONA_KEEP_PATIENT_REFERENCE', label: 'Keep patient names', kind: 'onoff', help: 'On: Flow keeps the patient name of each job for the invoice Reference.' },
+    { name: 'SEAZONA_SYNC_NOW', label: 'Include in Sync now', kind: 'onoff', default: 'on', help: 'On: Sync now on the Integrations page reads Seazona\'s new and changed orders, invoices and practices.' },
     { name: 'SEAZONA_API_READ_HIDE_PATIENT', label: 'Hide patient details', kind: 'onoff', help: 'On: an AI assistant reading Seazona through Flow gets no patient, note, file or clinical fields.' },
   ],
 };
 
+// The lanes Sync now reads: what changes from day to day. Products, lab
+// users, the history read and the sweep keep their own schedule.
+export const SYNC_NOW_LANES = Object.freeze(['invoices', 'orders_recent', 'orders_active', 'clients']);
+
 // What a person reads for each lane: the Seazona records it copies.
 const READ_NAMES = {
   invoices: 'invoices',
@@ -72,6 +77,10 @@ const readNames = (lanes) => lanes.map((lane) => READ_NAMES[lane.lane] ?? lane.l
 export function createSeazonaAdapter({ env = null, fetchImpl = null, now = Date.now, timers } = {}) {
   let runtime = null; // { settings, db, client, scheduler }
   const actReader = createActReader({ now });
+  // Sync now with no background sync (sandbox, replay, or background jobs
+  // off): one run at a time, and when the last one ended.
+  let manual = null;
+  let manualLast = null;
 
   function current() {
     if (!runtime) throw new Error('The Seazona adapter has not started');
@@ -121,6 +130,7 @@ export function createSeazonaAdapter({ env = null, fetchImpl = null, now = Date.
 
     async stop() {
       await runtime?.scheduler?.stop();
+      await manual;
       runtime = null;
     },
 
@@ -178,6 +188,40 @@ export function createSeazonaAdapter({ env = null, fetchImpl = null, now = Date.
         return alerts;
       },
 
+      // Sync now (server/core/sync-now.js): read new and changed orders,
+      // invoices and practices now, inside the rate governor. It answers at
+      // once; the run goes on in the background. Off while "Include in Sync
+      // now" is off, unless a person asked for Seazona alone (`asked`, its own
+      // Sync button).
+      async syncNow({ asked = false } = {}) {
+        if (!runtime) return { state: 'unavailable', reason: 'Seazona has not started' };
+        if (!runtime.settings.syncNow && !asked) return { state: 'off' };
+        const options = { only: SYNC_NOW_LANES };
+        if (runtime.scheduler) {
+          const state = runtime.scheduler.runNow(options);
+          return state === 'stopped' ? { state: 'unavailable', reason: 'Seazona is stopping' } : { state };
+        }
+        if (manual) return { state: 'running' };
+        const at = new Date(Number(now())).toISOString();
+        manual = runtime.run(options)
+          .then((result) => { manualLast = { at, ok: result.ok }; })
+          .catch(() => { manualLast = { at, ok: false }; })
+          .finally(() => { manual = null; });
+        return { state: 'started' };
+      },
+
+      async syncNowStatus() {
+        if (!runtime) return { included: false, running: false, lastAt: null, ok: null };
+        const scheduled = runtime.scheduler?.status();
+        const last = scheduled ? scheduled.lastRun : manualLast;
+        return {
+          included: runtime.settings.syncNow,
+          running: Boolean(scheduled?.running || manual),
+          lastAt: last?.at ?? null,
+          ok: last ? last.ok : null,
+        };
+      },
+
       // Billable work since a cursor: complete and shipped orders that
       // changed, with the Seazona invoice that carries each one. Orders
       // deleted in Seazona are never billable; they come back in `withdrawn`

package/server/integrations/seazona/lanes.js

@@ -28,6 +28,7 @@ import {
   recordOrderFailure,
   recordRecordFailure,
   selectActiveOrders,
+  syncRemakeFlags,
   touchSynced,
   upsertRecords,
   upsertReference,
@@ -507,6 +508,8 @@ const laneRuns = {
       else failures.push(result.failure);
     }
     await touchSynced(db, 'orders', unchanged, { at });
+    // The remake flag is on the list row: kept with no detail read.
+    await syncRemakeFlags(db, new Map(unchanged.map((id) => [id, byId.get(id)?.isRemake === true])), { at });
     summary.unchanged += unchanged.length;
     const failureDetails = judgeReads('recent order reads', detailReads, failures);
     const through = lastDone ?? (Number.isFinite(doneThrough) ? doneThrough : null);

package/server/integrations/seazona/ledger.js

@@ -60,6 +60,7 @@ export function toLedgerJob(item) {
     jobDate: item.invoice?.invoiceDate ?? item.dueOn ?? item.orderedOn ?? null,
     // The draft rules bill only the statuses the lab chose (for example Shipped).
     sourceStatus: item.status ?? null,
+    remake: item.remake === true,
     lines,
     sourceTotals,
     observedAt: item.syncedAt,

package/server/integrations/seazona/map.js

@@ -136,6 +136,8 @@ export function mapOrder(listItem = {}, detail = null, { keepPatientReference =
     lines,
     subtotalCents: lines.length ? sumCents(lines) : null,
     patientReference: keepPatientReference ? textOrNull(merged.patient) : null,
+    // Seazona's own remake flag (the list and the order both carry it).
+    remake: merged.isRemake === true,
   };
 }
 

package/server/integrations/seazona/migrations/0008_order_remake.sql

@@ -0,0 +1 @@
+ALTER TABLE "seazona_orders" ADD COLUMN IF NOT EXISTS "remake" boolean DEFAULT false NOT NULL;