@arcforgelabs/flow 2026.10.32-beta.1 → 2026.10.33

package/README.md

@@ -27,7 +27,8 @@ 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/DESIGN.md` | The design systems (theme families), how pages and Clerk's components take them, and the screens |
@@ -37,6 +38,7 @@ 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 |

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcforgelabs/flow",
-  "version": "2026.10.32-beta.1",
+  "version": "2026.10.33",
   "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/invoicing.js

@@ -13,13 +13,15 @@ import {
 } from '../core/line-mapping.js';
 import {
   effectiveSettings, INVOICING_DEFAULTS, readCustomerBilling, readInvoicingSettings,
-  saveCustomerBilling, saveInvoicingSettings, sendModeSummary,
+  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';
@@ -36,9 +38,9 @@ import {
 //   POST  /invoices/mark-ready        { invoiceIds }: a person checked these drafts; one with a problem stays
 //   POST  /invoices/mark-not-ready    { invoiceIds }: back to To check
 //   POST  /invoices/send-ready        owner or admin: issue every ready draft and queue it for the
-//                                     accounting system { issueDate }
+//                                     accounting system { issueDate, invoiceIds? (only these, each ready) }
 //   POST  /invoices/send-again        owner or admin: queue failed sends again { invoiceIds? }
-//   GET   /invoices/:id               one invoice: lines, contact, job, issued versions
+//   GET   /invoices/:id               one invoice: lines, contact, job, issued versions, and where it sends
 //   GET   /invoices/:id/pdf?version=  the invoice as a PDF, drawn by Flow (server/core/invoice-pdf.js),
 //                                     with the accounting system's number and dates once it holds it;
 //                                     no accounting system calls
@@ -250,6 +252,11 @@ async function invoiceDetail(db, organisationId, invoiceId, accounting = null) {
   return {
     ...invoice,
     ...(await invoiceView(db, organisationId, invoice, { accounting })),
+    // Where a draft goes when it is sent, and how: this customer's send mode.
+    sendsTo: accounting?.name ?? null,
+    sendMode: accounting && invoice.status === 'draft'
+      ? { mode: await sendModeFor(db, organisationId, invoice.contactId), otherCustomers: 0, ...(await accounting.capabilities.sendStatus({ organisationId })) }
+      : null,
     contact: contact ?? null,
     job: jobs.get(invoiceId) ?? null,
     versions: versions.map(({ version, issuedAt, issuedBy }) => ({ version, issuedAt, issuedBy })),
@@ -281,25 +288,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;
@@ -318,8 +336,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,
     });
   }));
 
@@ -348,7 +366,10 @@ export function createInvoicingRouter({
   router.post('/invoices/send-ready', ...manager, handle(log, async (req, res) => {
     const organisationId = await organisationOf(req);
     const issueDate = optionalDate(req.body?.issueDate, 'issueDate') ?? today();
-    const result = await sendAllReady(db, organisationId, { accounting: accounting(), personId: req.person.id, issueDate });
+    const ids = req.body?.invoiceIds === undefined ? null : invoiceIdsOf(req.body);
+    // 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 });
   }));
@@ -488,11 +509,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 { invoice } = await draftInvoiceForObligation(db, organisationId, obligationId, { liveCheck, actor: `person:${req.person.id}` });
+    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: 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/app.js

@@ -4,6 +4,7 @@ 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';
@@ -72,6 +73,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);
   });
 

package/server/core/automations.js

@@ -1,9 +1,10 @@
 import { and, eq, sql } from 'drizzle-orm';
 import { automations, billingObligations, invoices } from '../db/schema.js';
 import { FlowError, notFound } from './errors.js';
-import { autoDraftJobs } from './invoicing-rules.js';
+import { autoDraftJobs, readInvoicingSettings } from './invoicing-rules.js';
 import { MAPPING_DEFAULTS, readMappingConfig, remapJobs } from './line-mapping.js';
 import { setReady } from './ledger.js';
+import { refreshReferences } from './references.js';
 
 // Automations (docs/AUTOMATIONS.md): Flow's routines. Each one watches Flow's
 // own records and moves them on, and each is on or off with its own settings,
@@ -19,6 +20,8 @@ import { setReady } from './ledger.js';
 //     rules (invoicing-rules.js) gets a draft invoice in Flow.
 //   ready_when_drafted: a draft the draft routine made goes straight to Ready
 //     on the Invoices page, until a person changes it or moves it back.
+//   reference_from_rule: a draft made from a job keeps the Reference the
+//     lab's Reference rule gives (references.js), as the job's fields arrive.
 
 const BATCH = 500;
 
@@ -92,6 +95,14 @@ export const AUTOMATIONS = Object.freeze([
     defaults: { enabled: true, config: {} },
     readConfig: () => ({}),
   },
+  {
+    key: 'reference_from_rule',
+    place: 'invoicing',
+    name: 'Reference from the rule',
+    hint: 'A draft made from a job gets its Reference from the Reference rule. A Reference a person typed stays.',
+    defaults: { enabled: true, config: {} },
+    readConfig: () => ({}),
+  },
 ]);
 
 const byKey = new Map(AUTOMATIONS.map((a) => [a.key, a]));
@@ -169,16 +180,19 @@ async function readyWhenDrafted(db, organisationId) {
 
 // Runs every routine that is on. `accounting` is the integration whose copy
 // the draft routine checks; without one, Flow's own records are the check.
-export async function runAutomations(db, organisationId, { accounting = null, now = new Date() } = {}) {
+export async function runAutomations(db, organisationId, { accounting = null, work = null, now = new Date() } = {}) {
   const summary = {};
   for (const automation of await listAutomations(db, organisationId)) {
     if (!automation.enabled) continue;
     if (automation.key === 'mark_ready_from_work_status') {
       summary[automation.key] = await markReadyFromWorkStatus(db, organisationId, automation.config);
     } else if (automation.key === 'draft_when_ready') {
-      summary[automation.key] = await autoDraftJobs(db, organisationId, { accounting, now, actor: actorOf(automation.key) });
+      summary[automation.key] = await autoDraftJobs(db, organisationId, { accounting, work, now, actor: actorOf(automation.key) });
     } else if (automation.key === 'ready_when_drafted') {
       summary[automation.key] = await readyWhenDrafted(db, organisationId);
+    } else if (automation.key === 'reference_from_rule') {
+      const { referenceTemplate: template } = await readInvoicingSettings(db, organisationId);
+      summary[automation.key] = await refreshReferences(db, organisationId, { template, work });
     }
   }
   return summary;

package/server/core/invoices.js

@@ -98,8 +98,8 @@ export async function updateDraftInvoice(db, organisationId, invoiceId, changes)
     }
     if ('reference' in changes) fields.reference = changes.reference;
     if ('dueDate' in changes) fields.dueDate = changes.dueDate;
-    // A changed draft needs a person to check it again.
-    if (Object.keys(fields).length || 'lines' in changes) Object.assign(fields, { readyAt: null, readyBy: null });
+    // A saved change keeps the draft where it is. Flow's checks still run on
+    // it, so a change that breaks one puts the draft in Problem.
     let row = invoice;
     if (Object.keys(fields).length) {
       [row] = await tx.update(invoices).set({ ...fields, updatedAt: sql`now()` })

package/server/core/invoicing-rules.js

@@ -5,6 +5,8 @@ import {
 import { FlowError, notFound } from './errors.js';
 import { listRules, ruleReasons } from './invoice-rules.js';
 import { draftInvoiceForObligation } from './ledger.js';
+import { needsRead, readAccountingFirst, readBeforeAct, READS_PER_PASS } from './read-before-act.js';
+import { checkReferenceTemplate, DEFAULT_REFERENCE, jobReference } from './references.js';
 
 // Invoicing rules (docs/INVOICING_RULES.md). They are the checks a job that
 // is ready to invoice passes before Flow drafts its invoice, and how a checked
@@ -30,6 +32,7 @@ export const INVOICING_DEFAULTS = Object.freeze({
   requirePractitioner: false,
   rushItemCode: null,
   rushPercent: 20,
+  referenceTemplate: DEFAULT_REFERENCE,
 });
 
 const CUSTOMER_DEFAULTS = Object.freeze({
@@ -58,6 +61,15 @@ function shortText(value, name) {
   return value.trim() || null;
 }
 
+// An empty rule gives no Reference: the accounting system shows the number.
+function referenceTemplate(value) {
+  if (value === null) return '';
+  if (typeof value !== 'string' || value.length > 200) throw invalid('referenceTemplate must be text of 200 characters at most');
+  const problem = checkReferenceTemplate(value);
+  if (problem) throw invalid(`referenceTemplate: ${problem}`);
+  return value.trim();
+}
+
 function sendMode(value, name) {
   if (!SEND_MODES.includes(value)) throw invalid(`${name} must be one of ${SEND_MODES.join(', ')}`);
   return value;
@@ -79,6 +91,7 @@ function readSettingChanges(changes) {
     else if (key === 'paymentTermsDays') out[key] = wholeNumber(value, key, 0, 365);
     else if (key === 'rushPercent') out[key] = wholeNumber(value, key, 0, 100);
     else if (key === 'rushItemCode') out[key] = shortText(value, key);
+    else if (key === 'referenceTemplate') out[key] = referenceTemplate(value);
     else throw invalid(`unknown setting: ${key}`);
   }
   return out;
@@ -209,14 +222,20 @@ export function copyCheck(accounting, organisationId) {
   };
 }
 
+async function reloadObligation(db, organisationId, id) {
+  const [row] = await db.select().from(billingObligations)
+    .where(and(eq(billingObligations.organisationId, organisationId), eq(billingObligations.id, id)));
+  return row;
+}
+
 // Drafts the invoice of each job that is ready to invoice and passes the
 // ledger's checks and every rule, except for customers whose drafting is off.
 // It writes only Flow's own records: the drafts wait in Flow for a person.
 // The draft automation (automations.js) runs it. Answers counts.
 // With `accounting` null no accounting system is connected: Flow's own records
 // are the only check, as for a person's draft (ledger.js, ledgerView).
-export async function autoDraftJobs(db, organisationId, { accounting = null, now = new Date(), limit = DRAFT_BATCH, actor = ACTOR }) {
-  const result = { drafted: 0, waiting: 0, off: 0, refused: 0 };
+export async function autoDraftJobs(db, organisationId, { accounting = null, work = null, now = new Date(), limit = DRAFT_BATCH, actor = ACTOR }) {
+  const result = { drafted: 0, waiting: 0, off: 0, refused: 0, readFirst: 0 };
   const settings = await readInvoicingSettings(db, organisationId);
   const rules = await listRules(db, organisationId);
   if (accounting) {
@@ -239,22 +258,62 @@ export async function autoDraftJobs(db, organisationId, { accounting = null, now
   const customers = await customerBillingByContact(db, organisationId, candidates.map((o) => o.contactId));
   const liveCheck = accounting ? copyCheck(accounting, organisationId) : null;
   const invoiceDate = isoDay(now);
+  let accountingRead = null;
 
-  for (const obligation of candidates) {
-    const effective = effectiveSettings(settings, customers.get(obligation.contactId));
+  for (const candidate of candidates) {
+    let effective = effectiveSettings(settings, customers.get(candidate.contactId));
     if (!effective.autoDraft) {
       result.off += 1;
       continue;
     }
-    if (ruleBlockers(obligation, effective, { now, rules }).length) {
+    if (ruleBlockers(candidate, effective, { now, rules }).length) {
+      result.waiting += 1;
+      continue;
+    }
+    // Issue #141: an old report is read again first. The rules then check
+    // what the work system says now; the ledger checks the rest.
+    if (result.readFirst >= READS_PER_PASS && needsRead(candidate, { work, now })) {
+      result.waiting += 1;
+      continue;
+    }
+    let { outcome, obligation } = (await readBeforeAct(db, organisationId, [candidate], { work, now, actor })).get(candidate.id);
+    if (outcome !== 'fresh') result.readFirst += 1;
+    if (outcome === 'waiting' || outcome === 'review') {
       result.waiting += 1;
       continue;
     }
+    // Issue #45: the accounting copy reads its latest changes once, before
+    // the first draft. When it changed, the matcher ran: this job may now
+    // have its invoice.
+    if (accounting) {
+      if (!accountingRead) {
+        accountingRead = await readAccountingFirst(db, organisationId, { accounting, now });
+        // The summary says when the copy read or could not read.
+        if (accountingRead.outcome !== 'fresh') result.accountingRead = accountingRead.outcome;
+      }
+      if (accountingRead.outcome === 'waiting') {
+        result.waiting += 1;
+        continue;
+      }
+      if (accountingRead.outcome === 'read') obligation = await reloadObligation(db, organisationId, obligation.id);
+      if (obligation.accountingState !== 'not_found') {
+        result.waiting += 1;
+        continue;
+      }
+    }
+    if (obligation !== candidate) {
+      effective = effectiveSettings(settings, customers.get(obligation.contactId));
+      if (!effective.autoDraft || ruleBlockers(obligation, effective, { now, rules }).length) {
+        result.waiting += 1;
+        continue;
+      }
+    }
     try {
       await draftInvoiceForObligation(db, organisationId, obligation.id, {
         liveCheck,
         actor,
         now,
+        reference: await jobReference(db, organisationId, obligation, { template: settings.referenceTemplate, work }),
         dueDate: addDays(invoiceDate, effective.paymentTermsDays),
       });
       result.drafted += 1;

package/server/core/job-board.js

@@ -1,8 +1,8 @@
 import { and, eq, inArray, isNull } from 'drizzle-orm';
-import { contacts, invoices, priceItems } from '../db/schema.js';
+import { contacts, invoices, priceItems, reviewItems } from '../db/schema.js';
 import { listRules } from './invoice-rules.js';
 import { customerBillingByContact, effectiveSettings, readInvoicingSettings, ruleBlockers } from './invoicing-rules.js';
-import { listObligations } from './ledger.js';
+import { REVIEW_CHANGED, listObligations } from './ledger.js';
 import { isHistoryHeld } from './history.js';
 import { invoiceViews } from './sending.js';
 
@@ -21,7 +21,8 @@ import { invoiceViews } from './sending.js';
 export async function describeObligations(db, organisationId, listed, { accounting = null } = {}) {
   const contactIds = [...new Set(listed.map((e) => e.obligation.contactId).filter(Boolean))];
   const invoiceIds = [...new Set(listed.map((e) => e.obligation.invoiceId).filter(Boolean))];
-  const [names, numbers, views] = await Promise.all([
+  const changedIds = listed.filter((e) => e.obligation.holdState === 'review' && e.obligation.invoiceId).map((e) => e.obligation.id);
+  const [names, numbers, views, changed] = await Promise.all([
     contactIds.length
       ? db.select({ id: contacts.id, name: contacts.name }).from(contacts)
         .where(and(eq(contacts.organisationId, organisationId), inArray(contacts.id, contactIds)))
@@ -31,7 +32,16 @@ export async function describeObligations(db, organisationId, listed, { accounti
         .where(and(eq(invoices.organisationId, organisationId), inArray(invoices.id, invoiceIds)))
       : [],
     invoiceIds.length ? invoiceViews(db, organisationId, { accounting }) : null,
+    // The open "job changed" alerts (ledger.js): only the work system changed
+    // and the draft is not sent, so a person can use the new lines.
+    changedIds.length
+      ? db.select({ flowId: reviewItems.flowId, evidence: reviewItems.evidence }).from(reviewItems).where(and(
+        eq(reviewItems.organisationId, organisationId), eq(reviewItems.kind, REVIEW_CHANGED),
+        eq(reviewItems.state, 'open'), inArray(reviewItems.flowId, changedIds),
+      ))
+      : [],
   ]);
+  const offers = new Set(changed.filter((r) => r.evidence?.canUseNewLines).map((r) => r.flowId));
   const nameOf = new Map(names.map((c) => [c.id, c.name]));
   const invoiceOf = new Map(numbers.map((i) => [i.id, i]));
   const settings = await readInvoicingSettings(db, organisationId);
@@ -46,8 +56,9 @@ export async function describeObligations(db, organisationId, listed, { accounti
   // draft can still come from.
   const waitingFor = (o, v) => (o.invoiceId || !['in_work', 'ready', 'pending', 'held'].includes(v)
     ? [] : ruleBlockers(o, effectiveSettings(settings, customers.get(o.contactId)), { rules }));
-  return listed.map(({ obligation: { lineFingerprint: _fingerprint, organisationId: _org, ...o }, view, reasons }) => ({
+  return listed.map(({ obligation: { lineFingerprint: _fingerprint, organisationId: _org, draftBasis: _basis, ...o }, view, reasons }) => ({
     ...o,
+    canUseNewLines: offers.has(o.id),
     contactName: nameOf.get(o.contactId) ?? null,
     invoiceNumber: invoiceOf.get(o.invoiceId)?.number ?? null,
     invoiceStatus: invoiceOf.get(o.invoiceId)?.status ?? null,