@arcforgelabs/flow 2026.11.2 → 2026.11.3

package/SECURITY.md

@@ -31,6 +31,17 @@ paste a credential, in full or in part.
   person/client/organisation read grant. The first slice exposes four bounded read tools
   (`docs/AGENT_ACCESS.md`). The reserved `/api/flow/v1` stub still refuses all
   requests. It does not implement connector keys.
+- **AI assistant key.** Also off by default. When the host sets
+  `FLOW_AGENT_KEY_SHA256` and `FLOW_AGENT_EMAIL`, one bearer key acts as one
+  Flow person, inside that person's role, on `/api/me`, `/api/invoicing/…`,
+  `/api/xero/…` (never connect or disconnect), `GET /api/seazona/api/…` and the Seazona history import `/api/seazona/history…` only (`docs/AGENT_ACCESS.md`, "AI assistant key").
+  With the admin role that includes invoice writes: rules, void, delete draft
+  and send to the accounting system. Flow stores only the key's SHA-256; the key
+  stays with the assistant. Owner actions always refuse the key. Turning the
+  person off stops the key on the next request and stops sends it queued. The
+  Seazona read answers what Seazona gives, patient fields included; the owner
+  can turn on "Hide patient details" to drop them. Use an assistant whose model
+  runs locally or with zero data retention.
 - **Integrations.** Seazona, Xero and every later adapter reach the core only
   through the integration port. Their credentials are stored per
   organisation, encrypted, and are write-only in Settings.

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcforgelabs/flow",
-  "version": "2026.11.2",
+  "version": "2026.11.3",
   "description": "Invoicing, bill entry and a financial dashboard for labs, with Seazona and Xero integrations.",
   "license": "MIT",
   "repository": {
@@ -20,6 +20,7 @@
   },
   "files": [
     "server/",
+    "skills/",
     "SECURITY.md",
     "VISION.md",
     "npm-shrinkwrap.json"

package/server/api/invoicing.js

@@ -4,6 +4,7 @@ import { invoiceKindOf, invoicePage, INVOICE_SORTS, normaliseInvoicesView } from
 import { fieldIdOf, filterRows } from '../ui/job-view.js';
 import { listFields, listJobFieldValues } from '../core/custom-fields.js';
 import { FlowError } from '../core/errors.js';
+import { listReview } from '../core/review.js';
 import { createActionGuard } from '../integrations/call-guard.js';
 import {
   createDraftInvoice, deleteDraft, getInvoice, issueInvoice, listInvoiceVersions, reviseInvoice, updateDraftInvoice, voidInvoice,
@@ -27,7 +28,7 @@ import {
   acceptFindings, archivePriceItem, checkPrices, createPriceItem, linkPriceItem, linkPriceItems, MAX_LINKS_AT_ONCE, readCatalogues, readPriceList, unlinkPriceItem, updatePriceItem,
 } from '../core/price-list.js';
 import {
-  confirmNoInvoice, draftInvoiceForObligation, explainObligation, jobChangeFor, linkJobToInvoice, listObligations,
+  confirmNoInvoice, draftInvoiceForObligation, freeVoidedJob, setHold, explainObligation, jobChangeFor, linkJobToInvoice, listObligations,
   setReady, settleJobChange, useSourceLines,
 } from '../core/ledger.js';
 import { isHistoryHeld } from '../core/history.js';
@@ -99,6 +100,8 @@ import {
 //   PUT   /contacts/:id/billing       owner or admin: change them (null takes the organisation's)
 //   POST  /jobs/:id/ready             { ready }: mark a job ready to invoice, or back in work
 //   GET   /jobs/:id/activity          what happened to a job, newest first
+//   POST  /jobs/:id/hold              owner or admin: { state: none|held|review, reason }
+//   POST  /jobs/:id/free              owner or admin: { reason }: let go of a void invoice, then hold
 //   POST  /jobs/:id/draft             owner or admin: a job's draft invoice, after a live
 //                                     check that the accounting system holds none
 //
@@ -825,6 +828,23 @@ export function createInvoicingRouter({
     res.json({ ok: true, ...await listReconcile(db, organisationId) });
   }));
 
+  // The open review queue (core/review.js): daily reconcile days, job
+  // changes, links Flow could not prove, failed writes. Read only: each item
+  // closes when its cause is fixed (or by the screen that owns it).
+  router.get('/review', ...signedIn, handle(log, async (req, res) => {
+    const organisationId = await organisationOf(req);
+    const state = text(req.query.state) || 'open';
+    if (!['open', 'resolved', 'dismissed'].includes(state)) throw new FlowError('invalid', 'state must be open, resolved or dismissed');
+    const kind = text(req.query.kind) || undefined;
+    const limit = Math.min(Math.max(Number.parseInt(text(req.query.limit) || '100', 10) || 100, 1), 500);
+    const items = await listReview(db, organisationId, { state, kind, limit });
+    res.json({ ok: true, items: items.map((r) => ({
+      id: r.id, kind: r.kind, entity: r.entity, flowId: r.flowId, systems: r.systems, evidence: r.evidence,
+      moneyAtRiskCents: r.moneyAtRiskCents, seenCount: r.seenCount, state: r.state, resolution: r.resolution,
+      createdAt: r.createdAt, updatedAt: r.updatedAt,
+    })) });
+  }));
+
   router.get('/jobs/:id/reconcile', ...signedIn, handle(log, async (req, res) => {
     const obligationId = pathId(req.params.id, 'job');
     const organisationId = await organisationOf(req);
@@ -848,10 +868,39 @@ export function createInvoicingRouter({
   router.post('/jobs/:id/no-invoice', ...manager, handle(log, async (req, res) => {
     const obligationId = pathId(req.params.id, 'job');
     const organisationId = await organisationOf(req);
-    const job = await confirmNoInvoice(db, organisationId, obligationId, { actor: `person:${req.person.id}` });
+    const job = await confirmNoInvoice(db, organisationId, obligationId, { actor: `person:${req.person.id}`, system: accounting()?.id ?? null });
     res.json({ ok: true, job: { id: job.id, accountingState: job.accountingState } });
   }));
 
+  // Holds a job, sends it to review, or releases it (state "none"). Every
+  // change needs a reason, kept in the job's activity.
+  router.post('/jobs/:id/hold', ...manager, handle(log, async (req, res) => {
+    const obligationId = pathId(req.params.id, 'job');
+    const organisationId = await organisationOf(req);
+    const state = text(req.body?.state);
+    const reason = text(req.body?.reason);
+    if (!['none', 'held', 'review'].includes(state)) throw invalid('state must be none, held or review');
+    if (!reason) throw invalid('a reason is required');
+    const [current] = await db.select({ holdState: billingObligations.holdState, holdReason: billingObligations.holdReason }).from(billingObligations)
+      .where(and(eq(billingObligations.organisationId, organisationId), eq(billingObligations.id, obligationId)));
+    if (state === 'none' && isHistoryHeld(current)) {
+      throw invalid('this is a history-import hold: settle it with the history import decisions');
+    }
+    const job = await setHold(db, organisationId, obligationId, { holdState: state, reason, actor: `person:${req.person.id}` });
+    res.json({ ok: true, job: { id: job.id, holdState: job.holdState, holdReason: job.holdReason } });
+  }));
+
+  // Frees a job stuck on a void Flow invoice, or on an accounting invoice that
+  // was voided or deleted there. The job goes on hold until a person releases it.
+  router.post('/jobs/:id/free', ...manager, handle(log, async (req, res) => {
+    const obligationId = pathId(req.params.id, 'job');
+    const organisationId = await organisationOf(req);
+    const reason = text(req.body?.reason);
+    if (!reason) throw invalid('a reason is required');
+    const job = await freeVoidedJob(db, organisationId, obligationId, { actor: `person:${req.person.id}`, reason, system: accounting()?.id ?? null });
+    res.json({ ok: true, job: { id: job.id, invoiceId: job.invoiceId, accountingState: job.accountingState, holdState: job.holdState, holdReason: job.holdReason } });
+  }));
+
   // Links a job to a Flow invoice that already exists.
   router.post('/jobs/:id/link', ...manager, handle(log, async (req, res) => {
     const obligationId = pathId(req.params.id, 'job');

package/server/auth/routes.js

@@ -1,3 +1,4 @@
+import { readFile } from 'node:fs/promises';
 import express from 'express';
 import { FlowError } from '../core/errors.js';
 import { rateLimit } from '../rate-limit.js';
@@ -18,6 +19,9 @@ import {
   updatePerson,
 } from './people.js';
 import { isPlainEmail } from './settings.js';
+
+// The files of skills/flow that GET /api/agent-skill/flow/<file> serves.
+const SKILL_FILES = { 'SKILL.md': 'text/markdown', 'flow.sh': 'text/x-shellscript' };
 import { APP_PATHS, appPage } from '../ui/app-page.js';
 import { navPinsFromViews } from '../ui/nav-pins.js';
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -110,6 +114,22 @@ export function createSignInRouter({ settings, db, clerk, personAuth, defaultFam
     res.json(body);
   });
 
+  // The AI assistant's own skill, from the Flow it talks to, so the skill
+  // always matches this Flow's routes (`flow.sh update`). Only the two skill
+  // files; the release that runs here is the one they come from.
+  router.get('/api/agent-skill/flow/:file', requireSession, async (req, res) => {
+    const file = SKILL_FILES[req.params.file];
+    if (!file) return res.status(404).json({ ok: false, code: 'not_found', error: 'No such skill file.' });
+    try {
+      const text = await readFile(new URL(`../../skills/flow/${req.params.file}`, import.meta.url), 'utf8');
+      res.set('Cache-Control', 'no-store');
+      res.type(file).send(text);
+    } catch (error) {
+      log.error?.(`[auth] skill file ${req.params.file} unreadable: ${error.message}`);
+      res.status(503).json({ ok: false, code: 'skill_unavailable', error: 'This Flow has no skill files.' });
+    }
+  });
+
   // Each person sets their own appearance; it follows their account.
   router.put('/api/me/appearance', requireSession, express.json({ limit: '4kb' }), async (req, res) => {
     try {

package/server/auth/session.js

@@ -1,3 +1,4 @@
+import { createHash, timingSafeEqual } from 'node:crypto';
 import { displayNameOf, googleWorkspaceOwner, primaryEmailOf, secondFactorVerified } from './clerk.js';
 import { fillPersonName, findPersonByClerkId, findPersonByEmail, linkPerson, recordPendingPerson } from './people.js';
 import { DEFAULT_OWNER_MFA_MAX_AGE_MINUTES, isPlainEmail } from './settings.js';
@@ -52,6 +53,7 @@ export function createPersonAuth({
   log = console,
   now = Date.now,
   clerkUserCacheMs = 60 * 1000,
+  agentKey = null,
 }) {
   if (!db) throw new Error('createPersonAuth: db is required');
   if (!clerk?.authenticate || !clerk?.getUser) throw new Error('createPersonAuth: a Clerk adapter is required');
@@ -118,7 +120,9 @@ export function createPersonAuth({
   // Every person route starts here. The session token must be in the
   // Authorization header; Clerk verifies it, and Flow checks its expiry too.
   async function requireSession(req, res, next) {
-    if (!bearerToken(req)) return deny(res, 'signed_out');
+    const token = bearerToken(req);
+    if (!token) return deny(res, 'signed_out');
+    if (agentKey && isAgentKey(token)) return agentSession(req, res, next);
     let auth;
     try {
       auth = await clerk.authenticate(req);
@@ -145,6 +149,37 @@ export function createPersonAuth({
     return next();
   }
 
+  // The AI assistant key (FLOW_AGENT_KEY). It acts as one Flow person, and
+  // only inside that person's role. Owner actions stay with people: an agent
+  // request is never a verified owner sign-in.
+  // Keys shorter than 32 characters are refused, so a digest of a short
+  // guess never matches.
+  const agentDigest = agentKey ? Buffer.from(agentKey.digest, 'hex') : null;
+  function isAgentKey(token) {
+    return token.length >= 32 && timingSafeEqual(createHash('sha256').update(token).digest(), agentDigest);
+  }
+  // The key opens only these routes: invoicing, Xero (owner routes refuse it
+  // below), the Seazona read, the Seazona history import, /api/me and its own
+  // skill files.
+  const AGENT_PATHS = /^\/api\/(?:me$|invoicing\/|xero\/|seazona\/(?:api|history)(?:\/|$)|agent-skill\/flow\/)/;
+  async function agentSession(req, res, next) {
+    if (!AGENT_PATHS.test(`${req.baseUrl}${req.path}`)) return deny(res, 'role_required');
+    let person;
+    try {
+      person = await findPersonByEmail(db, agentKey.email);
+    } catch (error) {
+      log.error?.(`[auth] Flow agent person lookup failed: ${error.message}`);
+      return deny(res, 'sign_in_unavailable');
+    }
+    if (!person) return deny(res, 'not_invited');
+    if (person.status !== 'active') return deny(res, 'access_disabled');
+    req.person = person;
+    req.clerkAuth = null;
+    req.agent = true;
+    log.info?.(`[auth] agent key: ${req.method} ${req.baseUrl}${req.path} as Flow person ${person.id} (${person.role})`);
+    return next();
+  }
+
   function requireRole(...roles) {
     return (req, res, next) => (roles.includes(req.person?.role) ? next() : deny(res, 'role_required'));
   }
@@ -165,6 +200,7 @@ export function createPersonAuth({
   //       (Replit's managed Clerk, which has no MFA).
   // A Clerk error fails closed. Returns { verified, by } or { unavailable }.
   async function ownerVerification(person, auth) {
+    if (!auth) return { verified: false, by: null };
     if (secondFactorVerified(auth, ownerMfaMaxAgeMinutes)) return { verified: true, by: 'second_factor' };
     if (!ownerGoogleDomains.length) return { verified: false, by: null };
     try {
@@ -182,6 +218,7 @@ export function createPersonAuth({
   // requireSession.
   async function requireOwner(req, res, next) {
     if (req.person?.role !== 'owner') return deny(res, 'owner_required');
+    if (req.agent) return deny(res, 'owner_verification_required', ownerMessage);
     const check = await ownerVerification(req.person, req.clerkAuth);
     if (check.unavailable) return deny(res, 'sign_in_unavailable');
     if (!check.verified) return deny(res, 'owner_verification_required', ownerMessage);

package/server/auth/settings.js

@@ -127,6 +127,21 @@ export function isPlainEmail(email) {
   return typeof email === 'string' && /^[\x21-\x3f\x41-\x7e]+@[a-z0-9.-]+\.[a-z0-9-]+$/i.test(email);
 }
 
+// FLOW_AGENT_KEY_SHA256 and FLOW_AGENT_EMAIL: one key for one AI assistant
+// (an OpenClaw Gateway). A request with `Authorization: Bearer <key>`, where
+// the key's SHA-256 is FLOW_AGENT_KEY_SHA256, acts as the Flow person with
+// FLOW_AGENT_EMAIL, inside that person's role. Flow holds only the digest, so
+// the key itself never leaves the assistant's machine. Both or neither.
+export function resolveAgentKey(env = process.env) {
+  const digest = readEnv(env, 'FLOW_AGENT_KEY_SHA256').toLowerCase();
+  const email = readEnv(env, 'FLOW_AGENT_EMAIL').toLowerCase();
+  if (!digest && !email) return null;
+  if (!digest || !email) throw new Error('FLOW_AGENT_KEY_SHA256 and FLOW_AGENT_EMAIL must be set together');
+  if (!/^[0-9a-f]{64}$/.test(digest)) throw new Error('FLOW_AGENT_KEY_SHA256 must be 64 hex characters (the SHA-256 of the key)');
+  if (!isPlainEmail(email)) throw new Error('FLOW_AGENT_EMAIL must be a plain (ASCII) email address');
+  return { digest, email };
+}
+
 export function resolveSignInSettings(env = process.env) {
   const mode = resolveAuthMode(env);
   if (mode === 'off') return { mode };
@@ -139,5 +154,6 @@ export function resolveSignInSettings(env = process.env) {
     ownerGoogleDomains: parseOwnerGoogleDomains(readEnv(env, 'FLOW_OWNER_GOOGLE_DOMAINS')),
     authorizedParties: resolveAuthorizedParties(env),
     firstOwnerEmail: resolveFirstOwnerEmail(env),
+    agentKey: resolveAgentKey(env),
   };
 }

package/server/core/job-match.js

@@ -101,8 +101,9 @@ export async function listReconcile(db, organisationId) {
     status: billingObligations.sourceStatus,
     sourceSystem: billingObligations.sourceSystem,
     sourceJobRef: billingObligations.sourceJobRef,
-    // An unclear accounting match: "Make invoice" settles it first.
-    unclear: sql`${billingObligations.accountingState} = 'ambiguous'`.mapWith(Boolean),
+    // An unclear accounting match, or a matched accounting invoice that was
+    // voided or deleted there: "Make invoice" settles it first.
+    unclear: sql`${billingObligations.accountingState} in ('ambiguous', 'voided', 'deleted') and ${billingObligations.invoiceId} is null`.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}
@@ -152,8 +153,9 @@ export async function jobMatchDetail(db, organisationId, obligationId, { referen
     lines: jobLines(o, codes),
     totalCents: o.totalCents,
     open: !o.invoiceId && !o.accountingRef,
-    // An unclear accounting match: "Make invoice" settles it first.
-    unclear: o.accountingState === 'ambiguous',
+    // An unclear accounting match, or a matched accounting invoice that was
+    // voided or deleted there: "Make invoice" settles it first.
+    unclear: !o.invoiceId && ['ambiguous', 'voided', 'deleted'].includes(o.accountingState),
   };
 
   const search = String(q ?? '').trim();

package/server/core/ledger.js

@@ -769,7 +769,51 @@ export async function setHold(db, organisationId, obligationId, { holdState, rea
     const obligation = await loadObligation(tx, organisationId, obligationId, { lock: true });
     const row = await update(tx, obligation, { holdState, holdReason: holdState === 'none' ? null : reason.trim() });
     await addEvent(tx, row, holdState === 'none' ? 'released' : holdState, actor, {
-      from: obligation.holdState, reason: row.holdReason,
+      from: obligation.holdState, reason: holdState === 'none' ? (reason?.trim() || null) : row.holdReason,
+    });
+    return row;
+  });
+}
+
+const GONE_STATES = ['voided', 'deleted'];
+
+// A person (or the assistant, after the lab says yes) frees a job that is
+// stuck on an invoice that bills nothing now: a Flow invoice that was voided,
+// or an accounting invoice that was voided or deleted there. The job lets go
+// of that invoice and goes on hold, so nothing drafts until a person releases
+// it (setHold to 'none'). A Flow invoice that is still live must be voided
+// first: this never voids or changes an invoice.
+export async function freeVoidedJob(db, organisationId, obligationId, { actor, reason, system = null }) {
+  requireActor(actor);
+  if (!reason?.trim()) throw new FlowError('invalid', 'say why the job is freed');
+  return db.transaction(async (tx) => {
+    const obligation = await loadObligation(tx, organisationId, obligationId, { lock: true });
+    let flowInvoice = null;
+    if (obligation.invoiceId) {
+      [flowInvoice] = await tx.select({ id: invoices.id, number: invoices.number, status: invoices.status }).from(invoices)
+        .where(and(eq(invoices.organisationId, organisationId), eq(invoices.id, obligation.invoiceId)));
+      if (flowInvoice && flowInvoice.status !== 'void') {
+        throw new FlowError('invalid', `Flow invoice ${flowInvoice.number ?? flowInvoice.id} is ${flowInvoice.status}: void it first, then free the job`);
+      }
+    }
+    const gone = GONE_STATES.includes(obligation.accountingState) ? obligation.accountingRef : null;
+    if (!flowInvoice && !gone) throw new FlowError('invalid', 'the job is not linked to a void or deleted invoice');
+    const row = await update(tx, obligation, {
+      ...(flowInvoice ? { invoiceId: null, draftBasis: null } : {}),
+      ...(gone || GONE_STATES.includes(obligation.accountingState)
+        ? { accountingState: 'not_found', accountingRef: null, accountingUrl: null, accountingMatchedBy: null, accountingCheckedAt: sql`now()` }
+        : {}),
+      holdState: 'held',
+      holdReason: reason.trim(),
+    });
+    if (gone && system) {
+      await tx.insert(linkRejections).values({ organisationId, obligationId: obligation.id, system, externalId: gone, actor }).onConflictDoNothing();
+    }
+    await addEvent(tx, row, 'freed', actor, {
+      reason: reason.trim(),
+      ...(flowInvoice ? { invoiceId: flowInvoice.id } : {}),
+      ...(gone ? { released: gone } : {}),
+      from: obligation.holdState,
     });
     return row;
   });
@@ -777,9 +821,10 @@ export async function setHold(db, organisationId, obligationId, { holdState, rea
 
 // A job with no invoice of its own whose accounting evidence is ambiguous:
 // the matcher found accounting invoices that may be this job's, but none
-// exactly. A person settles it on the Reconcile page: "Make invoice", or a
-// link to a Flow invoice (linkJobToInvoice).
-const unlinked = (o) => o.accountingState === 'ambiguous' && !o.invoiceId && !o.accountingRef;
+// exactly. Or the accounting invoice the matcher linked was voided or deleted
+// there: it bills nothing now. A person settles it on the Reconcile page or
+// the job: "Make invoice", or a link to a Flow invoice (linkJobToInvoice).
+const unlinked = (o) => !o.invoiceId && (GONE_STATES.includes(o.accountingState) || (o.accountingState === 'ambiguous' && !o.accountingRef));
 
 // The matcher's open suggestions for one job, best first.
 export async function linkSuggestionsFor(db, organisationId, obligationId) {
@@ -814,14 +859,26 @@ async function rejectSuggestions(tx, obligation, { actor }) {
 // "Make invoice": a person says the job has no invoice yet. Every suggestion
 // is rejected and the job is recorded as not found, so it can draft. The
 // live check before the draft still runs (draftInvoiceForObligation).
-export async function confirmNoInvoice(db, organisationId, obligationId, { actor }) {
+// `system` is the accounting system's id: a released voided or deleted link
+// becomes that person's "not this one" too, so the matcher never offers it.
+export async function confirmNoInvoice(db, organisationId, obligationId, { actor, system = null }) {
   requireActor(actor);
   return db.transaction(async (tx) => {
     const obligation = await loadObligation(tx, organisationId, obligationId, { lock: true });
     if (!unlinked(obligation)) throw new FlowError('invalid', 'the job is not waiting for a person to settle its invoice');
     const rejected = await rejectSuggestions(tx, obligation, { actor });
-    const row = await update(tx, obligation, { accountingState: 'not_found', accountingCheckedAt: sql`now()` });
-    await addEvent(tx, row, 'accounting_checked', actor, { reported: 'not_found', state: 'not_found', matchedBy: 'person', rejected });
+    // A voided or deleted link is let go, so the matcher stops following it.
+    const gone = GONE_STATES.includes(obligation.accountingState) ? obligation.accountingRef : null;
+    const row = await update(tx, obligation, {
+      accountingState: 'not_found', accountingCheckedAt: sql`now()`,
+      ...(gone ? { accountingRef: null, accountingUrl: null, accountingMatchedBy: null } : {}),
+    });
+    if (gone && system) {
+      await tx.insert(linkRejections).values({ organisationId, obligationId: obligation.id, system, externalId: gone, actor }).onConflictDoNothing();
+    }
+    await addEvent(tx, row, 'accounting_checked', actor, {
+      reported: 'not_found', state: 'not_found', matchedBy: 'person', rejected, ...(gone ? { released: gone } : {}),
+    });
     return row;
   });
 }

package/server/core/pipeline.js

@@ -342,6 +342,10 @@ export function rankCandidates(obligation, invoices, { prior = null, rivals = []
 
 const amountsAgree = (obligation, invoice) => totalsFor(obligation).has(invoice.totalCents);
 const withoutReissue = (ref) => String(ref).replace(/R$/i, '');
+// A voided or deleted accounting invoice bills nothing: it never links a job
+// by itself. A lab that reissued work voids the first invoice, and that one
+// keeps the work system's number.
+const live = (invoice) => !['voided', 'deleted'].includes(invoice.state);
 
 async function saveSuggestions(db, organisationId, obligationId, system, ranked) {
   const keep = ranked.slice(0, 5);
@@ -392,14 +396,14 @@ export async function matchJob(db, organisationId, obligation, {
   });
   if (prior) {
     const [invoice] = await find({ invoiceIds: [prior.externalId] });
-    if (invoice && !rejected.has(invoice.id) && (prior.matchedBy === 'person' || amountsAgree(obligation, invoice))) {
+    if (invoice && live(invoice) && !rejected.has(invoice.id) && (prior.matchedBy === 'person' || amountsAgree(obligation, invoice))) {
       return exact(invoice, 'prior_link');
     }
   }
   if (obligation.sourceInvoiceRef) {
     const numbers = [obligation.sourceInvoiceRef, withoutReissue(obligation.sourceInvoiceRef)];
     const same = (await find({ numbers }))
-      .filter((i) => !rejected.has(i.id) && (!xeroContactId || i.contactId === xeroContactId));
+      .filter((i) => live(i) && !rejected.has(i.id) && (!xeroContactId || i.contactId === xeroContactId));
     if (same.length === 1) return exact(same[0], 'source_invoice_ref');
   }
   // Without the customer's accounting contact there is nothing to compare.

package/server/core/sending.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { and, asc, desc, eq, inArray, sql } from 'drizzle-orm';
-import { billingObligations, contacts, invoiceLines, invoices } from '../db/schema.js';
+import { billingObligations, contacts, invoiceLines, invoices, people } from '../db/schema.js';
 import { FlowError } from './errors.js';
 import { listRules, ruleNonChargeable, rulePending, ruleSkip } from './invoice-rules.js';
 import { customerBillingByContact, effectiveSettings, readInvoicingSettings } from './invoicing-rules.js';
@@ -430,6 +430,11 @@ export function refusalReport(result) {
   return `[sending] the accounting system refused ${count} ${word}${detail ? `: ${detail}` : ''}`;
 }
 
+async function requesterActive(db, personId) {
+  const [row] = await db.select({ status: people.status }).from(people).where(eq(people.id, personId));
+  return row?.status === 'active';
+}
+
 // One pass of the send worker: up to `limit` queued invoices, oldest first.
 export async function sendQueued(db, organisationId, { accounting, limit = WORKER_BATCH }) {
   const rows = await db.select({ id: invoices.id, number: invoices.number, by: invoices.sendRequestedBy }).from(invoices)
@@ -439,6 +444,17 @@ export async function sendQueued(db, organisationId, { accounting, limit = WORKE
   const summary = { sent: 0, failed: 0, waiting: 0 };
   for (const [by, group] of Map.groupBy(rows, (r) => r.by ?? null)) {
     const known = new Map(group.map((row) => [row.id, row]));
+    // A send waits in the queue. The person who asked for it must still be
+    // active when it goes, so turning a person (or an assistant's key) off
+    // also stops what they queued.
+    if (by && !(await requesterActive(db, by))) {
+      for (const row of group) {
+        await settle(db, organisationId, row.id, { sendState: 'failed', sendError: { code: 'requester_disabled', message: 'The person who asked to send this is turned off. Send it again.' } });
+        summary.failed += 1;
+      }
+      summary.refused = [...new Set([...(summary.refused ?? []), 'requester_disabled'])];
+      continue;
+    }
     const { invoices: results } = await accounting.capabilities.pushInvoices({
       organisationId, invoiceIds: group.map((r) => r.id), pushedBy: by,
     });

package/server/integrations/seazona/index.js

@@ -53,6 +53,7 @@ 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_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.' },
   ],
 };
 
@@ -85,7 +86,11 @@ export function createSeazonaAdapter({ env = null, fetchImpl = null, now = Date.
     schema: seazonaSchema,
     setup: SEAZONA_SETUP,
     // The history import's routes (routes.js), under /api/seazona.
-    routes: ({ db, personAuth, log }) => createSeazonaRouter({ db: runtime?.db ?? db, personAuth, settings: current().settings, log }),
+    routes: ({ db, personAuth, log }) => createSeazonaRouter({
+      db: runtime?.db ?? db, personAuth, settings: current().settings, log,
+      read: (path, query) => current().client.get(path, query),
+      hidePatientFields: () => Boolean(current().settings.sync.hidePatientFields),
+    }),
     // Every Seazona call goes through this call guard, inside the rate
     // governor (governor.js; docs/INTEGRATIONS.md, "Outbound calls").
     callGuard: SEAZONA_CALL_GUARD,

package/server/integrations/seazona/routes.js

@@ -36,7 +36,16 @@ import { readBackfill, startBackfill, stopBackfill } from './history/backfill.js
 //                                         (state: one state, or needs_person)
 //   POST /history/ledger/:obligationId/release   owner or admin: the job may draft
 //
-// None of these call Seazona.
+// None of these call Seazona, except one read:
+//
+//   GET  /api/<resource>[/<id>]?<query>   owner or admin: one GET to the
+//                                         Seazona REST API, through Flow's
+//                                         rate governor, answered as
+//                                         { ok, data }. resource is invoices,
+//                                         orders, clients, products or users.
+//                                         It never writes to Seazona. It is how
+//                                         an AI assistant reads Seazona with its
+//                                         Flow key (docs/AGENT_ACCESS.md).
 
 export const MAX_UPLOAD = '25mb';
 
@@ -56,7 +65,40 @@ const handle = (log, fn) => async (req, res) => {
   }
 };
 
-export function createSeazonaRouter({ db, personAuth, settings, log = console }) {
+const API_RESOURCES = ['invoices', 'orders', 'clients', 'products', 'users'];
+
+// With "Hide patient details" on (SEAZONA_API_READ_HIDE_PATIENT), any field
+// whose name says patient, note, file, prescription and the like is dropped
+// from the read, at any depth. Off by default.
+const PRIVATE_FIELD = /patient|note|comment|instruction|remark|file|attach|image|photo|prescri|shade|clinical|medical|birth|dob/i;
+// The value is parsed JSON, so it has no cycles.
+export function withoutPrivateFields(value) {
+  if (Array.isArray(value)) return value.map(withoutPrivateFields);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.entries(value)
+    .filter(([key]) => !PRIVATE_FIELD.test(key))
+    .map(([key, item]) => [key, withoutPrivateFields(item)]));
+}
+// A list read must carry the filter Flow's own sync uses. Seazona answers a
+// list without it with an error, and every error counts against the call
+// guard that also protects Flow's sync, so Flow refuses it before the call.
+const SEAZONA_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/;
+const LIST_FILTERS = {
+  orders: { key: 'ordered', hint: 'ordered=2026-11-11T00:00:00 (one day)' },
+  invoices: { key: 'lastModified', hint: 'lastModified=2026-11-01T00:00:00' },
+  clients: { key: 'lastModified', hint: 'lastModified=2026-11-01T00:00:00' },
+};
+export function listQueryProblem(resource, query) {
+  const filter = LIST_FILTERS[resource];
+  if (filter && !SEAZONA_TIME.test(query[filter.key] ?? '')) return `A ${resource} list needs ${filter.hint}.`;
+  for (const key of ['page', 'pageSize']) {
+    if (key in query && !/^[1-9]\d{0,2}$/.test(query[key])) return `${key} must be a whole number from 1 to 999.`;
+  }
+  return null;
+}
+const API_PATH = new RegExp(`^/api/(${API_RESOURCES.join('|')})(?:/([A-Za-z0-9-]{1,64}))?/?$`);
+
+export function createSeazonaRouter({ db, personAuth, settings, read = null, hidePatientFields = () => false, log = console }) {
   const router = express.Router();
   // Sign-in off: every route answers 503, as the Xero routes do.
   const signedIn = personAuth
@@ -72,6 +114,27 @@ export function createSeazonaRouter({ db, personAuth, settings, log = console })
     return router;
   }
 
+  // One read from the Seazona API (above). Only plain query values pass on.
+  router.get(API_PATH, ...manager, handle(log, async (req, res) => {
+    if (!read) throw Object.assign(new FlowError('seazona_off', 'Seazona is not connected'), { status: 503 });
+    const [, resource, id] = API_PATH.exec(req.path);
+    const query = {};
+    for (const [key, value] of Object.entries(req.query)) {
+      if (typeof value === 'string' && /^[A-Za-z][A-Za-z0-9_]{0,40}$/.test(key)) query[key] = value.slice(0, 200);
+    }
+    const problem = id ? null : listQueryProblem(resource, query);
+    if (problem) return res.status(400).json({ ok: false, code: 'invalid', error: problem });
+    try {
+      const data = await read(id ? `${resource}/${id}` : `${resource}/`, query);
+      log.info?.(`[seazona] api read ${resource}${id ? '/:id' : ''} by ${actor(req)}`);
+      res.json({ ok: true, data: hidePatientFields() ? withoutPrivateFields(data) : data });
+    } catch (error) {
+      if (error?.name !== 'SeazonaApiError' && error?.name !== 'SeazonaCallsStopped') throw error;
+      const status = error.statusCode === 404 ? 404 : error.statusCode === 400 ? 400 : error.name === 'SeazonaCallsStopped' || error.statusCode === 429 || error.kind === 'governor_timeout' ? 429 : 502;
+      res.status(status).json({ ok: false, code: 'seazona_read_failed', error: error.message });
+    }
+  }));
+
   router.get('/history', ...signedIn, handle(log, async (req, res) => {
     res.json({ ok: true, history: await historySummary(db), backfill: await readBackfill(db), batches: await listBatches(db) });
   }));

package/server/integrations/seazona/settings.js

@@ -187,6 +187,9 @@ export function resolveSeazonaSettings(env = process.env) {
     // print one. Off by default; on, orders and invoices keep Seazona's
     // patient field as the reference.
     keepPatientReference: ['1', 'true', 'on', 'yes'].includes(text(env.SEAZONA_KEEP_PATIENT_REFERENCE).toLowerCase()),
+    // Off by default: the Seazona read (routes.js) answers what Seazona gives.
+    // On, it drops patient, note, file and clinical fields first.
+    hidePatientFields: ['1', 'true', 'on', 'yes'].includes(text(env.SEAZONA_API_READ_HIDE_PATIENT).toLowerCase()),
   };
 
   const settings = {

package/server/integrations/xero/ledger.js

@@ -119,7 +119,11 @@ export async function checkInvoice(db, runtime, client, organisationId, obligati
   // 3. The work system's own invoice number, as Xero's number or reference.
   if (obligation.sourceInvoiceRef) {
     const byId = new Map();
-    for (const inv of sales(await client.findInvoicesByNumber(obligation.sourceInvoiceRef))) byId.set(inv.InvoiceID, inv);
+    // Its reissue too (a trailing R): a lab that reissued the work voided the
+    // first invoice and bills the R one. One call: Xero takes a list.
+    const base = obligation.sourceInvoiceRef.replace(/R$/i, '');
+    const numbers = [...new Set([obligation.sourceInvoiceRef, base, `${base}R`])].join(',');
+    for (const inv of sales(await client.findInvoicesByNumber(numbers))) byId.set(inv.InvoiceID, inv);
     for (const inv of sales(await client.findInvoicesByReference(obligation.sourceInvoiceRef))) byId.set(inv.InvoiceID, inv);
     const found = [...byId.values()];
     if (found.length === 1) return evidenceFor(runtime, client, found[0], 'source_invoice_ref', checkedAt);

package/server/ui/app-page.js

@@ -51,7 +51,7 @@ const BODY = `<div class="fx-app">
   <div id="toasts" class="fx-toasts" aria-live="polite"></div>
 </div>`;
 
-export const APP_PATHS = ['/sign-in', '/jobs', '/captures', '/invoices', '/invoices/:id', '/contacts', '/contacts/:id', '/reconcile', '/reconcile/:id', '/xero-import', '/people', '/integrations', '/integrations/:id', '/account', '/appearance', '/invoicing-settings', '/invoicing-settings/:id', '/automations', '/price-list', '/price-list/:id', '/custom-fields'];
+export const APP_PATHS = ['/sign-in', '/home', '/jobs', '/captures', '/invoices', '/invoices/:id', '/contacts', '/contacts/:id', '/reconcile', '/reconcile/:id', '/xero-import', '/people', '/integrations', '/integrations/:id', '/account', '/appearance', '/invoicing-settings', '/invoicing-settings/:id', '/automations', '/price-list', '/price-list/:id', '/custom-fields'];
 
 export function appPage({ defaultFamily }) {
   return renderPage({