@arcforgelabs/flow 2026.10.40 → 2026.10.42

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcforgelabs/flow",
-  "version": "2026.10.40",
+  "version": "2026.10.42",
   "description": "Invoicing, bill entry and a financial dashboard for labs, with Seazona and Xero integrations.",
   "license": "MIT",
   "repository": {

package/server/api/invoicing.js

@@ -43,7 +43,8 @@ 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, invoiceIds? (only these, each ready) }
+//                                     accounting system { issueDate, invoiceIds? (only these; one that fails
+//                                     a check now stays on Pending and counts as held) }
 //   POST  /invoices/send-again        owner or admin: queue failed sends again { invoiceIds? }
 //   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),
@@ -542,8 +543,10 @@ export function createInvoicingRouter({
     // the job at its source or adopt the change (ledger.js), as Move to
     // Ready and Send do.
     const { problems } = await invoiceView(db, organisationId, await getInvoice(db, organisationId, invoiceId));
-    const held = problems.find((p) => p.code === 'job_review');
-    if (held) throw new FlowError('not_ready', `${held.message} Nothing was approved.`);
+    // A lab's pending rule (invoice-rules.js) is a gate too: fix its cause
+    // or turn the rule off.
+    const held = problems.find((p) => p.code === 'job_review' || p.code === 'rule');
+    if (held) throw new FlowError('not_ready', `${held.message.replace(/\.?$/, '.')} Nothing was approved.`);
     const issued = await issueInvoice(db, organisationId, invoiceId, { issuedBy: `person:${req.person.id}`, issueDate });
     log.info?.(`[invoicing] organisation ${organisationId}: person ${req.person.id} issued invoice ${issued.number} (version ${issued.issuedVersion})`);
     res.json({ ok: true, invoice: await invoiceDetail(db, organisationId, invoiceId, accounting(), work()) });
@@ -773,7 +776,7 @@ export function createInvoicingRouter({
   // with their tests, and the values Flow already holds for each kind of menu.
   router.get('/rule-fields', ...signedIn, handle(log, async (req, res) => {
     const organisationId = await organisationOf(req);
-    const [statuses, customers, items] = await Promise.all([
+    const [statuses, customers, items, practitioners] = await Promise.all([
       workStatuses(db, organisationId),
       db.select({ value: contacts.id, label: contacts.name }).from(contacts)
         .where(and(eq(contacts.organisationId, organisationId), eq(contacts.kind, 'customer')))
@@ -781,13 +784,20 @@ export function createInvoicingRouter({
       db.select({ value: priceItems.code, label: priceItems.name }).from(priceItems)
         .where(and(eq(priceItems.organisationId, organisationId), isNull(priceItems.archivedAt)))
         .orderBy(asc(priceItems.code)).limit(1000),
+      // The practitioners on the jobs, as the work system wrote them, most used first.
+      db.select({ value: billingObligations.practitioner, n: sql`count(*)::int` }).from(billingObligations)
+        .where(and(eq(billingObligations.organisationId, organisationId), sql`coalesce(trim(${billingObligations.practitioner}), '') <> ''`))
+        .groupBy(billingObligations.practitioner).orderBy(sql`count(*) desc`, asc(billingObligations.practitioner)).limit(500),
     ]);
     res.json({
       ok: true,
-      fields: Object.entries(FIELDS).map(([key, f]) => ({ key, label: f.label, kind: f.kind, options: f.options ?? null, tests: TESTS[f.kind] })),
+      fields: Object.entries(FIELDS).map(([key, f]) => ({
+        key, label: f.label, kind: f.kind, options: f.options ?? null, tests: TESTS[f.kind], draftOnly: Boolean(f.draftOnly),
+      })),
       actions: ACTIONS,
       options: {
         statuses: statuses.map((s) => ({ value: s.value, label: s.label })),
+        practitioners: practitioners.map((p) => ({ value: p.value, label: `${p.value} (${p.n})` })),
         customers,
         items: [
           ...items.map((i) => ({ value: i.value, label: `${i.value} · ${i.label}` })),

package/server/core/invoice-rules.js

@@ -9,7 +9,10 @@ import { FlowError, notFound } from './errors.js';
 //   When  job_ready: the job is ready to invoice and has no invoice yet.
 //   If    every condition matches: a field of the job, its customer or its
 //         lines, a test, and a value.
-//   Then  wait: the job waits for a person; skip: rules never draft it.
+//   Then  wait: the job waits for a person; skip: rules never draft it;
+//         pending: Flow drafts it, and the draft is Pending with the rule's
+//         note, which says what to fix (for example a Reference with no
+//         real practitioner).
 //
 // The rules read only Flow's own records, so they work with or without an
 // accounting integration. The earlier fixed settings (old job limit, required
@@ -19,6 +22,7 @@ const MAX_RULES = 100;
 const MAX_CONDITIONS = 10;
 const invalid = (message) => new FlowError('invalid', message);
 
+const MAX_NOTE = 200;
 const day = (date) => new Date(`${String(date).slice(0, 10)}T00:00:00Z`);
 const norm = (value) => String(value ?? '').trim().replace(/\s+/g, ' ').toLowerCase();
 // A line's key: its price item code, else the label line mapping gave it (a
@@ -40,7 +44,9 @@ export const FIELDS = Object.freeze({
   job_age_days: { label: 'Job age (days)', kind: 'number', read: (j, { now }) => (j.jobDate ? Math.floor((now - day(j.jobDate)) / 86_400_000) : null) },
   job_total: { label: 'Job total', kind: 'money', read: (j) => (j.totalCents ?? 0) / 100 },
   job_status: { label: 'Job status', kind: 'choice', options: 'statuses', read: (j) => norm(j.sourceStatus) || null },
-  practitioner: { label: 'Practitioner', kind: 'text', read: (j, { customer }) => j.practitioner || customer.defaultPractitioner || null },
+  practitioner: { label: 'Practitioner', kind: 'text', options: 'practitioners', read: (j, { customer }) => j.practitioner || customer.defaultPractitioner || null },
+  // Only a draft has a Reference, so only a pending rule may read it.
+  reference: { label: 'Reference', kind: 'text', draftOnly: true, read: (j) => j.reference || null },
   customer: { label: 'Customer', kind: 'choice', options: 'customers', read: (j) => j.contactId },
   customer_billable: { label: 'Customer is billable', kind: 'boolean', read: (j, { customer }) => customer.billable !== false },
   line_item: { label: 'Line item', kind: 'items', options: 'items', read: (j) => (j.lines ?? []).flatMap((l) => [norm(l.itemCode), norm(l.label)].filter(Boolean)) },
@@ -51,13 +57,15 @@ export const TESTS = Object.freeze({
   number: ['more_than', 'at_most', 'is', 'is_not', 'is_empty'],
   money: ['more_than', 'at_most', 'is', 'is_not'],
   choice: ['is', 'is_not', 'is_one_of', 'is_empty'],
-  text: ['is', 'is_not', 'is_empty', 'is_not_empty'],
+  text: ['is', 'is_not', 'is_one_of', 'is_not_one_of', 'contains', 'does_not_contain', 'starts_with', 'does_not_start_with', 'has_number', 'one_word', 'is_empty', 'is_not_empty'],
   boolean: ['is'],
   items: ['has', 'has_not'],
   share: ['is', 'is_not'],
 });
 
-export const ACTIONS = Object.freeze(['wait', 'skip']);
+export const ACTIONS = Object.freeze(['wait', 'skip', 'pending']);
+// Tests that take no value.
+const NO_VALUE = new Set(['is_empty', 'is_not_empty', 'has_number', 'one_word']);
 
 function readCondition(raw, index) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw invalid(`condition ${index + 1} must be an object`);
@@ -65,13 +73,13 @@ function readCondition(raw, index) {
   if (!field) throw invalid(`condition ${index + 1}: unknown field ${raw.field}`);
   if (!TESTS[field.kind].includes(raw.test)) throw invalid(`condition ${index + 1}: ${field.label} takes ${TESTS[field.kind].join(', ')}`);
   const out = { field: raw.field, test: raw.test };
-  if (['is_empty', 'is_not_empty'].includes(raw.test)) return out;
+  if (NO_VALUE.has(raw.test)) return out;
   const { value } = raw;
   if (field.kind === 'boolean') {
     if (typeof value !== 'boolean') throw invalid(`condition ${index + 1}: the value must be true or false`);
   } else if (['number', 'money', 'share'].includes(field.kind)) {
     if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1e9) throw invalid(`condition ${index + 1}: the value must be a number`);
-  } else if (raw.test === 'is_one_of') {
+  } else if (['is_one_of', 'is_not_one_of'].includes(raw.test)) {
     if (!Array.isArray(value) || !value.length || value.length > 50 || value.some((v) => typeof v !== 'string' || !v.trim() || v.length > 200)) {
       throw invalid(`condition ${index + 1}: pick 1 to 50 values`);
     }
@@ -98,7 +106,17 @@ export function readRule(raw) {
     throw invalid(`the rule needs 1 to ${MAX_CONDITIONS} conditions`);
   }
   if (!ACTIONS.includes(raw.action?.kind)) throw invalid(`the action must be one of ${ACTIONS.join(', ')}`);
-  return { name, enabled, conditions: raw.conditions.map(readCondition), action: { kind: raw.action.kind } };
+  const conditions = raw.conditions.map(readCondition);
+  const action = { kind: raw.action.kind };
+  if (action.kind === 'pending') {
+    const note = typeof raw.action.note === 'string' ? raw.action.note.trim() : '';
+    if (!note || note.length > MAX_NOTE) throw invalid(`a pending rule needs a note of ${MAX_NOTE} characters at most: what a person must fix`);
+    action.note = note;
+  } else {
+    const early = conditions.find((c) => FIELDS[c.field].draftOnly);
+    if (early) throw invalid(`${FIELDS[early.field].label} is on the draft only: use Then "Pending, with a note"`);
+  }
+  return { name, enabled, conditions, action };
 }
 
 function matches(condition, job, context) {
@@ -107,6 +125,18 @@ function matches(condition, job, context) {
   const { test, value } = condition;
   if (test === 'is_empty') return have === null || have === '' || have === undefined;
   if (test === 'is_not_empty') return !(have === null || have === '' || have === undefined);
+  if (field.kind === 'text' && !['is', 'is_not', 'is_one_of'].includes(test)) {
+    // An empty text matches no test that reads its words; is_empty finds it.
+    const left = norm(have);
+    if (!left) return false;
+    if (test === 'is_not_one_of') return !value.some((v) => norm(v) === left);
+    if (test === 'has_number') return /\d/.test(left);
+    if (test === 'one_word') return !left.includes(' ');
+    if (test === 'contains') return left.includes(norm(value));
+    if (test === 'does_not_contain') return !left.includes(norm(value));
+    if (test === 'starts_with') return left.startsWith(norm(value));
+    if (test === 'does_not_start_with') return !left.startsWith(norm(value));
+  }
   switch (field.kind) {
     case 'items': {
       const found = have.includes(norm(value));
@@ -142,13 +172,24 @@ export function ruleReasons(rules, job, { customer = {}, now = new Date() } = {}
   const context = { customer, now };
   const reasons = [];
   for (const rule of rules) {
-    if (!rule.enabled || rule.trigger !== 'job_ready') continue;
+    if (!rule.enabled || rule.trigger !== 'job_ready' || rule.action.kind === 'pending') continue;
     if (!rule.conditions.every((c) => matches(c, job, context))) continue;
     reasons.push(rule.action.kind === 'skip' ? `rule "${rule.name}": not drafted by rule` : `rule "${rule.name}": waits for a person`);
   }
   return reasons;
 }
 
+// The notes of the enabled pending rules that match one draft, as problems:
+// they put the draft on Pending (sending.js). `job` is the draft's job with
+// `reference`, the draft's Reference. A pending rule never stops a draft.
+export function rulePending(rules, job, { customer = {}, now = new Date() } = {}) {
+  const context = { customer, now };
+  return rules
+    .filter((r) => r.enabled && r.trigger === 'job_ready' && r.action.kind === 'pending')
+    .filter((r) => r.conditions.every((c) => matches(c, job, context)))
+    .map((r) => ({ code: 'rule', message: r.action.note, short: r.name.slice(0, 40), rule: r.id ?? null }));
+}
+
 // The starter rules made from the earlier fixed settings.
 export function starterRules(settings) {
   const rules = [

package/server/core/job-match.js

@@ -97,6 +97,8 @@ export async function listReconcile(db, organisationId) {
     practitioner: billingObligations.practitioner,
     jobDate: billingObligations.jobDate,
     totalCents: billingObligations.totalCents,
+    // An unclear accounting match: "Make invoice" settles it first.
+    unclear: sql`${billingObligations.accountingState} = 'ambiguous'`.mapWith(Boolean),
     possible: sql`(select count(*) from invoices i
       where i.organisation_id = ${billingObligations.organisationId} and i.contact_id = ${billingObligations.contactId}
         and i.status <> 'void' and i.total_cents = ${billingObligations.totalCents}

package/server/core/sending.js

@@ -2,6 +2,8 @@ import { randomUUID } from 'node:crypto';
 import { and, asc, desc, eq, inArray, sql } from 'drizzle-orm';
 import { billingObligations, invoiceLines, invoices } from '../db/schema.js';
 import { FlowError } from './errors.js';
+import { listRules, rulePending } from './invoice-rules.js';
+import { customerBillingByContact, effectiveSettings, readInvoicingSettings } from './invoicing-rules.js';
 import { issueInvoice } from './invoices.js';
 import { CHANGED_REASON, diffJobLines, STATUS_BACK_REASON } from './ledger.js';
 import { soleOrganisation } from './pipeline.js';
@@ -14,7 +16,8 @@ import { deadHoldSince, deadSince, enqueueJob, runNextJob } from './queue.js';
 // a total above zero, and a price item (or, for a line such as a rush
 // charge, an account) on every line. When an accounting
 // system is connected, its own checks are added (for Xero: the customer
-// matches one Xero contact, every item is in Xero). A draft with a problem is
+// matches one Xero contact, every item is in Xero), and the lab's pending
+// rules (invoice-rules.js) add their notes. A draft with a problem is
 // Pending (the "problem" view). A draft without one is Ready.
 //
 // Send all ready issues every ready draft (each gets its number) and, when an
@@ -77,10 +80,25 @@ async function checkDrafts(db, organisationId, drafts, accounting) {
     const found = draftProblems(draft, linesOf.get(draft.id) ?? []);
     if (found.length) problems.set(draft.id, found);
   }
+  const jobs = await db.select({ obligation: billingObligations, reference: invoices.reference }).from(billingObligations)
+    .innerJoin(invoices, eq(invoices.id, billingObligations.invoiceId))
+    .where(and(eq(billingObligations.organisationId, organisationId), inArray(billingObligations.invoiceId, ids)));
+  // The lab's pending rules (invoice-rules.js): a draft from a job that
+  // matches one waits on Pending with the rule's note, such as a Reference
+  // with no real practitioner.
+  const rules = (await listRules(db, organisationId)).filter((r) => r.enabled && r.action.kind === 'pending');
+  if (rules.length && jobs.length) {
+    const settings = await readInvoicingSettings(db, organisationId);
+    const customers = await customerBillingByContact(db, organisationId, jobs.map((j) => j.obligation.contactId));
+    for (const { obligation, reference } of jobs) {
+      const customer = effectiveSettings(settings, customers.get(obligation.contactId));
+      const found = rulePending(rules, { ...obligation, reference }, { customer });
+      if (found.length) problems.set(obligation.invoiceId, [...(problems.get(obligation.invoiceId) ?? []), ...found]);
+    }
+  }
   // A draft whose job the ledger sent to review (the job changed after the
   // draft was made, or the work system deleted it) waits for a person.
-  const reviewed = await db.select().from(billingObligations)
-    .where(and(eq(billingObligations.organisationId, organisationId), inArray(billingObligations.invoiceId, ids), eq(billingObligations.holdState, 'review')));
+  const reviewed = jobs.map((j) => j.obligation).filter((o) => o.holdState === 'review');
   for (const obligation of reviewed) {
     const { invoiceId, holdReason: reason } = obligation;
     const found = problem('job_review', `The job needs a look before this invoice goes: ${reason ?? 'it was sent to review'}.`, reviewShort(obligation));
@@ -201,11 +219,21 @@ export async function sendAllReady(db, organisationId, { accounting = null, work
   let views = await invoiceViews(db, organisationId, { accounting });
   const accountingRead = views.ready.length ? await readAccountingFirst(db, organisationId, { accounting, now }) : { outcome: 'fresh' };
   if (accountingRead.changed) views = await invoiceViews(db, organisationId, { accounting });
+  // Every check runs again at the press, as a gate: a ticked draft that
+  // fails one now (someone edited it, its job changed, a rule matches) is not
+  // sent and stays on Pending with its problem. The rest go.
   let { ready } = views;
+  let held = 0;
   if (invoiceIds) {
     const wanted = new Set(invoiceIds);
     ready = ready.filter((id) => wanted.has(id));
-    if (ready.length !== wanted.size) throw new FlowError('not_ready', 'Only a ready invoice can be sent. Mark it ready first.');
+    held = wanted.size - ready.length;
+    if (!ready.length) {
+      const reason = invoiceIds.map((id) => views.problems.get(id)?.[0]?.message).find(Boolean);
+      throw new FlowError('not_ready', reason
+        ? `Not sent: ${reason.replace(/\.?$/, '.')} The invoice is on Pending.`
+        : 'Only a ready invoice can be sent. Mark it ready first.');
+    }
   }
   const { go, waiting } = accountingRead.outcome === 'waiting'
     ? { go: [], waiting: ready.slice(0, SEND_BATCH) }
@@ -229,7 +257,7 @@ export async function sendAllReady(db, organisationId, { accounting = null, work
     }
     issued += 1;
   }
-  return { issued, queued: accounting ? issued : 0, remaining: Math.max(0, ready.length - SEND_BATCH), waiting: waiting.length };
+  return { issued, queued: accounting ? issued : 0, remaining: Math.max(0, ready.length - SEND_BATCH), waiting: waiting.length, held };
 }
 
 // Send again: issued invoices that failed go back on the queue. With no ids,

package/server/ui/flow.css

@@ -387,9 +387,6 @@ a.fx-strong:hover { text-decoration: underline; }
 .fx-tabs button[aria-selected="true"] { color: var(--t-strong); border-bottom-color: var(--t-brand); }
 .fx-tabs__count { padding: 0 7px; border-radius: 999px; background: var(--fx-hover); color: var(--t-dim); font-size: 12px; line-height: 20px; }
 .fx-tabs button[data-tone="danger"] .fx-tabs__count { background: var(--t-danger-bg); color: var(--t-danger); }
-/* Invoices: the Send all ready bar above the Ready list. */
-.fx-sendbar { display: flex; align-items: center; justify-content: space-between; gap: 12px; flex-wrap: wrap; margin: 0 0 12px; padding: 12px 16px; border: 1px solid var(--fx-line); border-radius: 8px; background: var(--t-paper); margin-top: 12px; }
-.fx-sendbar[hidden] { display: none; }
 
 /* Quiet alerts (server/ui/alerts.js): one slim line under the page header,
    only while something on the page needs this person. */
@@ -409,9 +406,7 @@ a.fx-strong:hover { text-decoration: underline; }
   .fx-alerts__text { flex-basis: calc(100% - 52px); }
   .fx-alerts__action, .fx-alerts__more { order: 2; }
 }
-.fx-sendbar p { margin: 0; }
 .fx-problem { color: var(--t-danger); }
-.fx-sendbar__actions { display: flex; flex-wrap: wrap; gap: 8px; }
 .fx-tick-cell { width: 40px; }
 .fx-tick { width: 16px; height: 16px; accent-color: var(--t-brand); cursor: pointer; }
 .fx-search { width: min(320px, 100%); margin-bottom: 8px; }
@@ -705,26 +700,15 @@ th:hover .fx-th-sort, .fx-th-sort:focus-visible, .fx-th-sort--on { opacity: 1; }
 .fx-task__none { display: inline-flex; align-items: center; gap: 6px; color: var(--t-warn); }
 .fx-task__none svg { width: 16px; height: 16px; }
 
-/* Reconcile: the queue left, one job and its possible invoices right. */
-.fx-rec { display: grid; grid-template-columns: 280px minmax(0, 1fr); border: 1px solid var(--fx-line); border-radius: var(--t-radius-lg); background: var(--t-paper); min-height: 420px; }
-.fx-rec > .fx-empty, .fx-rec > .fx-dim { grid-column: 1 / -1; }
-.fx-rec__queue { display: flex; flex-direction: column; border-right: 1px solid var(--fx-line); max-height: 75vh; overflow-y: auto; }
-.fx-rec__tabs { display: flex; flex-wrap: wrap; gap: 6px; padding: 12px 16px; border-bottom: 1px solid var(--fx-line); }
-.fx-rec__tab { display: inline-flex; align-items: center; min-height: 32px; padding: 0 10px; border: 1px solid var(--fx-line); border-radius: 999px; color: var(--t-text); font-size: 12.5px; font-weight: 600; text-decoration: none; }
-.fx-rec__tab[aria-selected="true"] { border-color: var(--t-primary); background: var(--t-primary); color: var(--t-on-primary); }
-.fx-rec__search { width: 100%; min-width: 0; }
+/* Reconcile (reconcile.js): the list, as Jobs and Invoices; one gap, as an
+   invoice opened from Invoices (the pager on top). */
+.fx-rec { display: flex; flex-direction: column; gap: 16px; min-width: 0; }
+.fx-rec .fx-lucide { width: 16px; height: 16px; }
+.fx-rec__gap { max-width: 1180px; }
+.fx-rec__gap .fx-toolbar .fx-rows__title { margin: 0; }
+.fx-rec__gap .fx-ph__actions .fx-btn, .fx-rec__acts .fx-btn { display: inline-flex; align-items: center; justify-content: center; gap: 6px; }
 .fx-rec__results { display: flex; flex-direction: column; gap: 16px; min-width: 0; }
-.fx-rec__item { display: grid; gap: 3px; min-height: 44px; padding: 12px 16px; border-bottom: 1px solid var(--fx-line-soft); border-left: 3px solid transparent; color: var(--t-text); text-decoration: none; }
-.fx-rec__item:hover { background: var(--fx-hover); }
-.fx-rec__item[aria-current="true"] { border-left-color: var(--t-accent); background: var(--t-s1); }
-.fx-rec__item-top { display: flex; justify-content: space-between; gap: 8px; }
-.fx-rec__item .fx-num { font-family: var(--t-data); font-variant-numeric: tabular-nums; }
-.fx-rec__detail { display: flex; flex-direction: column; gap: 16px; min-width: 0; padding: 20px 24px; }
-.fx-rec__head { display: flex; justify-content: space-between; align-items: flex-end; gap: 16px; flex-wrap: wrap; }
-.fx-rec__head > div { display: grid; gap: 2px; }
-.fx-rec__back { display: none; color: var(--t-accent); text-decoration: none; font-size: 13px; }
-.fx-rec__title { margin: 0; font-family: var(--t-display); font-weight: var(--t-display-weight); color: var(--t-strong); font-size: 24px; }
-.fx-rec__table { display: grid; grid-template-columns: 110px minmax(150px, 1fr) repeat(var(--cols), minmax(170px, 1fr)); border: 1px solid var(--fx-line); border-radius: var(--t-radius); overflow-x: auto; }
+.fx-rec__table { display: grid; grid-template-columns: 110px minmax(150px, 1fr) repeat(var(--cols), minmax(170px, 1fr)); border: 1px solid var(--fx-line); border-radius: var(--t-radius); background: var(--t-paper); overflow-x: auto; }
 .fx-rec__row { display: contents; }
 .fx-rec__row > span { display: flex; flex-direction: column; gap: 2px; padding: 10px 12px; border-top: 1px solid var(--fx-line-soft); font-size: 13.5px; color: var(--t-strong); }
 .fx-rec__row:first-child > span { border-top: 0; background: var(--t-s1); }
@@ -738,8 +722,6 @@ th:hover .fx-th-sort, .fx-th-sort:focus-visible, .fx-th-sort--on { opacity: 1; }
 [data-mark="same"] > .fx-rec__mark { color: var(--t-success); }
 [data-mark="differs"], [data-mark="differs"] > .fx-rec__mark { color: var(--t-warn); }
 .fx-rec__best { color: var(--t-success); font-size: 12px; font-weight: 700; }
-.fx-rec__foot { display: flex; justify-content: space-between; align-items: center; gap: 12px; flex-wrap: wrap; }
-.fx-rec__foot-acts { display: flex; gap: 10px; flex-wrap: wrap; }
 .fx-rec__cards { display: none; }
 .fx-rec__card { display: flex; flex-direction: column; gap: 6px; padding: 12px; border: 1px solid var(--fx-line); border-radius: var(--t-radius); font-size: 13.5px; color: var(--t-strong); }
 .fx-rec__card.fx-rec__job { border-color: transparent; }
@@ -747,20 +729,17 @@ th:hover .fx-th-sort, .fx-th-sort:focus-visible, .fx-th-sort--on { opacity: 1; }
 .fx-rec__card-top { display: flex; justify-content: space-between; gap: 8px; }
 .fx-rec__label { color: var(--t-dim); font-size: 12px; font-weight: 700; letter-spacing: .06em; text-transform: uppercase; }
 .fx-rec__checks { display: flex; flex-wrap: wrap; gap: 4px 12px; }
-@media (max-width: 1100px) {
-  .fx-rec { grid-template-columns: minmax(0, 1fr); min-height: 0; }
-  .fx-rec__queue { border-right: 0; max-height: none; }
-  .fx-rec--open .fx-rec__queue { display: none; }
-  .fx-rec:not(.fx-rec--open) .fx-rec__detail { display: none; }
-  .fx-rec__back { display: inline; }
-}
+.fx-rec-list tbody tr { cursor: pointer; }
+.fx-rec-list__kind { width: 36px; color: var(--t-dim); }
+.fx-rec-list__mid { width: 72px; text-align: center; white-space: nowrap; }
+.fx-rec__possible { display: inline-flex; align-items: center; gap: 4px; color: var(--t-dim); font-variant-numeric: tabular-nums; }
+.fx-rec__possible[data-state="some"] { color: var(--t-warn); }
 @media (max-width: 820px) {
-  .fx-rec__detail { padding: 16px; }
   .fx-rec__table { display: none; }
   .fx-rec__cards { display: flex; flex-direction: column; gap: 12px; }
-  .fx-rec__cards .fx-btn, .fx-rec__foot .fx-btn { min-height: 44px; }
-  .fx-rec__foot-acts { width: 100%; }
-  .fx-rec__foot-acts .fx-btn { flex: 1 1 auto; }
+  .fx-rec__cards .fx-btn, .fx-rec__gap .fx-ph__actions .fx-btn { min-height: 44px; }
+  .fx-rec__gap .fx-ph__actions { width: 100%; }
+  .fx-rec__gap .fx-ph__actions .fx-btn { flex: 1 1 auto; }
 }
 .fx-task__custom { margin-top: 24px; }
 .fx-task__custom h3 { margin: 0 0 4px; color: var(--t-dim); font-size: 12px; font-weight: 700; letter-spacing: .06em; text-transform: uppercase; }
@@ -1293,7 +1272,6 @@ body[data-state="loading"] .fx-loading { display: grid; justify-items: center; }
    Narrow, the app bar (60px) sits above it. */
 .fx-listhead { position: sticky; top: 0; z-index: 5; margin: -12px calc(-1 * clamp(16px, 4vw, 48px)) 0; padding: 12px clamp(16px, 4vw, 48px) 0; background: var(--t-bg); transition: box-shadow .15s; }
 .fx-listhead[data-stuck] { box-shadow: 0 10px 12px -12px rgba(0, 0, 0, .45); }
-.fx-listhead .fx-sendbar { margin-bottom: 12px; }
 .fx-listhead__edge { height: 0; margin-bottom: -20px; }
 @media (max-width: 820px) { .fx-listhead { top: 60px; } }
 /* On a phone the head would hide too many rows: it scrolls away. */
@@ -1389,3 +1367,11 @@ body[data-state="loading"] .fx-loading { display: grid; justify-items: center; }
 }
 .fx-xi-count { font-size: 18px; }
 .fx-xi-list td.fx-num:not(.fx-strong) { text-align: left; }
+
+/* A list's own search (view-bar.js findBox): an icon that opens into a box. */
+.fx-find { display: inline-flex; align-items: center; }
+.fx-find__button { display: inline-grid; place-items: center; width: 32px; height: 32px; padding: 0; }
+.fx-find__button .fx-lucide { width: 15px; height: 15px; }
+.fx-find__input { display: none; width: min(240px, 60vw); height: 32px; padding: 0 10px; }
+.fx-find--open .fx-find__input { display: block; }
+.fx-find--open .fx-find__button { display: none; }

package/server/ui/invoice-rules.js

@@ -11,9 +11,13 @@ const DOCS = 'https://github.com/arcforgelabs/flow/blob/main/docs/INVOICE_RULES.
 const TEST_LABELS = {
   more_than: 'is more than', at_most: 'is at most', is: 'is', is_not: 'is not', is_one_of: 'is one of',
   is_empty: 'is empty', is_not_empty: 'is not empty', has: 'has', has_not: 'does not have',
+  is_not_one_of: 'is not one of', contains: 'contains', does_not_contain: 'does not contain',
+  starts_with: 'starts with', does_not_start_with: 'does not start with', has_number: 'has a number', one_word: 'is one word',
 };
-const ACTION_LABELS = { wait: 'Wait for a person', skip: 'Never draft' };
-const NO_VALUE = ['is_empty', 'is_not_empty'];
+const ACTION_LABELS = { wait: 'Wait for a person', skip: 'Never draft', pending: 'Pending, with a note' };
+const NO_VALUE = ['is_empty', 'is_not_empty', 'has_number', 'one_word'];
+const MANY = ['is_one_of', 'is_not_one_of'];
+const TYPED = ['contains', 'does_not_contain', 'starts_with', 'does_not_start_with'];
 
 // A rule as one short line: "Job age (days) is more than 90 · Wait for a person".
 export function ruleSummary(rule, meta) {
@@ -33,7 +37,8 @@ export function ruleSummary(rule, meta) {
     const value = Array.isArray(c.value) ? c.value.map((v) => labelOf(field, v)).join(', ') : labelOf(field, c.value);
     return `${field.label} ${test} ${value}`;
   };
-  return `${rule.conditions.map(part).join(' and ')} · ${ACTION_LABELS[rule.action.kind] ?? rule.action.kind}`;
+  const then = rule.action.kind === 'pending' ? `Pending: ${rule.action.note}` : ACTION_LABELS[rule.action.kind] ?? rule.action.kind;
+  return `${rule.conditions.map(part).join(' and ')} · ${then}`;
 }
 
 export function rulesSection(ui, title = 'Rules') {
@@ -100,9 +105,19 @@ export function rulesSection(ui, title = 'Rules') {
         const box = numberBox(value, 'Value');
         valueHost.append(box);
         readValue = () => ({ value: Number(box.value) });
-      } else if (test === 'is_one_of') {
-        const chosen = new Set((Array.isArray(value) ? value : []).map((v) => String(v).toLowerCase()));
-        const boxes = options(field).map((o) => {
+      } else if (TYPED.includes(test) || (field.kind === 'text' && !MANY.includes(test) && !options(field).length)) {
+        const box = h('input', { class: 'fx-input', type: 'text', maxlength: '200', value: Array.isArray(value) ? value[0] ?? '' : value ?? '', 'aria-label': 'Value' });
+        valueHost.append(box);
+        readValue = () => ({ value: box.value });
+      } else if (MANY.includes(test)) {
+        const picked = Array.isArray(value) ? value : [];
+        const chosen = new Set(picked.map((v) => String(v).toLowerCase()));
+        // A value saved earlier that is no longer on the menu stays ticked.
+        const known = new Set(options(field).map((o) => String(o.value).toLowerCase()));
+        // Ticked values come first, so a long menu shows what the rule holds.
+        const list = [...picked.filter((v) => !known.has(String(v).toLowerCase())).map((v) => ({ value: v, label: v })), ...options(field)]
+          .sort((x, y) => Number(chosen.has(String(y.value).toLowerCase())) - Number(chosen.has(String(x.value).toLowerCase())));
+        const boxes = list.map((o) => {
           const box = h('input', { type: 'checkbox', value: o.value, checked: chosen.has(String(o.value).toLowerCase()) });
           return h('label', { class: 'fx-multi__option' }, box, h('span', {}, o.label));
         });
@@ -112,10 +127,6 @@ export function rulesSection(ui, title = 'Rules') {
         const select = choiceSelect(field, Array.isArray(value) ? value[0] : value, 'Value');
         valueHost.append(select);
         readValue = () => ({ value: select.value });
-      } else {
-        const box = h('input', { class: 'fx-input', type: 'text', value: value ?? '', 'aria-label': 'Value' });
-        valueHost.append(box);
-        readValue = () => ({ value: box.value });
       }
     }
 
@@ -144,6 +155,15 @@ export function rulesSection(ui, title = 'Rules') {
     const action = h('select', { class: 'fx-select', 'aria-label': 'Then' },
       Object.entries(ACTION_LABELS).map(([value, label]) => h('option', { value }, label)));
     action.value = draft?.action.kind ?? 'wait';
+    // A pending rule's note: what a person must fix. It shows on the draft.
+    const note = h('input', {
+      class: 'fx-input', maxlength: '200', value: draft?.action.note ?? '', 'aria-label': 'Note',
+      placeholder: 'For example: Put the practitioner in the job, then check the Reference.',
+    });
+    const noteField = h('div', { class: 'fx-field' }, h('span', { class: 'fx-label' }, 'Note on the draft'), note);
+    const showNote = () => { noteField.hidden = action.value !== 'pending'; };
+    action.addEventListener('change', showNote);
+    showNote();
     let editors = [];
     const list = h('div', { class: 'fx-rule__conditions' });
     const addCondition = (start) => {
@@ -174,9 +194,10 @@ export function rulesSection(ui, title = 'Rules') {
       title: rule ? 'Edit rule' : 'New rule',
       body: h('div', { class: 'fx-fields fx-rule__dialog' },
         label('Name', name),
-        label('When', h('span', { class: 'fx-dim' }, 'A job is ready to invoice and has no invoice.')),
+        label('When', h('span', { class: 'fx-dim' }, 'A job is ready to invoice. A pending rule also checks its draft and the Reference.')),
         label('If all of these match', list, more),
         label('Then', action),
+        noteField,
         remove),
       confirm: rule ? 'Save' : 'Add rule',
     });
@@ -186,7 +207,11 @@ export function rulesSection(ui, title = 'Rules') {
       return draw();
     }
     if (!data) return null;
-    const payload = { name: name.value, conditions: editors.map((e) => e.read()), action: { kind: action.value } };
+    const payload = {
+      name: name.value,
+      conditions: editors.map((e) => e.read()),
+      action: action.value === 'pending' ? { kind: 'pending', note: note.value } : { kind: action.value },
+    };
     const body = rule
       ? await send(`/api/invoicing/rules/${rule.id}`, 'PUT', payload)
       : await send('/api/invoicing/rules', 'POST', payload);
@@ -219,7 +244,7 @@ export function rulesSection(ui, title = 'Rules') {
     add?.addEventListener('click', () => edit(null));
     section.replaceChildren(
       h('h2', { class: 'fx-set__title' }, title),
-      h('p', { class: 'fx-set__hint', style: { margin: '0 0 4px' } }, 'A ready job waits, or is never drafted, when a rule matches.'),
+      h('p', { class: 'fx-set__hint', style: { margin: '0 0 4px' } }, 'When a rule matches, a ready job waits, is never drafted, or its draft is Pending with the rule\'s note.'),
       ...(rules.length ? rules.map(rowOf) : [h('p', { class: 'fx-dim' }, 'No rules. Every ready job is drafted.')]),
       h('div', { class: 'fx-rule__footer' }, add,
         h('a', { class: 'fx-dim', href: DOCS, target: '_blank', rel: 'noopener' }, 'How rules work')));