@7365admin1/layer-common 4.94.0 → 4.96.0

package/components/VehicleQrStickerDialog.vue

@@ -76,7 +76,34 @@
             Expired, blocklisted and inactive vehicles start unticked. Each sticker has a cut-off strip under the
             dashed line saying which unit and owner it is for - cut it off before pasting the sticker on the car.
           </p>
-          <iframe ref="frame" title="Sticker sheet preview" :srcdoc="docHtml" class="sticker-preview" />
+          <div class="text-subtitle-2 mt-3 mb-1">Sticker design</div>
+          <p class="text-caption text-medium-emphasis mb-2">
+            Pick a look for the stickers. Every choice here has been tested to scan with iSecure365 and iMA365, and the
+            QR code stays the same size. Your choice is remembered on this computer.
+          </p>
+          <v-row dense data-test="vehicle-qr-design">
+            <v-col cols="12" sm="6" md="4" lg>
+              <v-select v-model="design.dots" :items="DOT_OPTIONS" label="QR dots" density="compact" hide-details />
+            </v-col>
+            <v-col cols="12" sm="6" md="4" lg>
+              <v-select v-model="design.eyes" :items="EYE_OPTIONS" label="QR corners" density="compact" hide-details />
+            </v-col>
+            <v-col cols="12" sm="6" md="4" lg>
+              <v-select v-model="design.theme" :items="STICKER_THEMES" item-value="id" label="Colours" density="compact"
+                hide-details />
+            </v-col>
+            <v-col cols="12" sm="6" md="4" lg>
+              <v-select v-model="design.frame" :items="FRAME_OPTIONS" label="Sticker shape" density="compact" hide-details />
+            </v-col>
+            <v-col cols="12" sm="6" md="4" lg>
+              <v-select v-model="design.label" :items="LABEL_OPTIONS" label="Words under the plate" density="compact"
+                hide-details />
+            </v-col>
+            <v-col cols="12" sm="6" md="4" lg="auto" class="d-flex align-center">
+              <v-btn variant="text" size="small" class="text-none" @click="resetDesign">Back to the standard look</v-btn>
+            </v-col>
+          </v-row>
+          <iframe ref="frame" title="Sticker sheet preview" :srcdoc="docHtml" class="sticker-preview mt-3" />
         </template>
       </v-card-text>
 
@@ -114,6 +141,18 @@ import {
   type StickerItem,
   type StickerPlateRow,
 } from "../utils/vehicle-qr-sticker";
+import {
+  DEFAULT_STICKER_DESIGN,
+  DOT_OPTIONS,
+  EYE_OPTIONS,
+  FRAME_OPTIONS,
+  LABEL_OPTIONS,
+  QR_ECC,
+  STICKER_THEMES,
+  normalizeDesign,
+  stickerFaceSvg,
+  type StickerDesign,
+} from "../utils/vehicle-qr-design";
 
 const props = defineProps({
   modelValue: { type: Boolean, default: false },
@@ -143,6 +182,29 @@ const error = ref("");
 const docHtml = ref("");
 const frame = ref<HTMLIFrameElement | null>(null);
 const fromReissue = computed(() => props.vehicleIds.length > 0);
+const siteName = ref("");
+
+// The last design chosen in this browser. Storage can be blocked (private
+// window): then it is simply the standard look each time.
+const DESIGN_KEY = "vehicleQrStickerDesign";
+function loadDesign(): StickerDesign {
+  try {
+    return normalizeDesign(JSON.parse(localStorage.getItem(DESIGN_KEY) || "null"));
+  } catch {
+    return { ...DEFAULT_STICKER_DESIGN };
+  }
+}
+const design = reactive<StickerDesign>(loadDesign());
+watch(design, (d) => {
+  try {
+    localStorage.setItem(DESIGN_KEY, JSON.stringify(d));
+  } catch {
+    /* not saved - nothing else to do */
+  }
+});
+function resetDesign() {
+  Object.assign(design, DEFAULT_STICKER_DESIGN);
+}
 
 const allOnPageTicked = computed(() => plates.value.length > 0 && plates.value.every((p) => selected.value.includes(p.id)));
 const someOnPageTicked = computed(() => plates.value.some((p) => selected.value.includes(p.id)));
@@ -203,6 +265,7 @@ async function goReview() {
     const { ids, dropped: over } = idsForRequest(selected.value);
     const res = await getVehicleQrStickers(props.site, ids);
     items.value = (res?.items ?? []) as StickerItem[];
+    siteName.value = String((res as any)?.site?.name ?? "");
     missing.value = res?.missing ?? [];
     dropped.value = over;
     ticked.value = defaultStickerIds(items.value);
@@ -214,21 +277,25 @@ async function goReview() {
   }
 }
 
-// The same document is the preview and the print job. Error correction Q and a
-// 4-module quiet zone; the QR is drawn at 32 mm so it scans from arm's length.
-let renderToken = 0;
-watch([items, ticked], async () => {
-  const mine = ++renderToken;
-  const chosen = items.value.filter((i) => ticked.value.includes(i.vehicleId));
-  if (!chosen.length) {
-    docHtml.value = "";
-    return;
-  }
-  const svgs = await Promise.all(
-    chosen.map((i) => QRCode.toString(i.qr, { type: "svg", errorCorrectionLevel: "Q", margin: 4 })),
-  );
-  if (mine === renderToken) docHtml.value = buildStickerDocument(chosen, svgs);
-});
+// The same document is the preview and the print job. The QR content, error
+// correction (Q), 4-module quiet zone and 32 mm size are the same on every
+// design; only the look of the dots, corners, colours and frame changes.
+watch(
+  [items, ticked, design, siteName],
+  () => {
+    const chosen = items.value.filter((i) => ticked.value.includes(i.vehicleId));
+    if (!chosen.length) {
+      docHtml.value = "";
+      return;
+    }
+    const look = normalizeDesign(design);
+    const faces = chosen.map((i) =>
+      stickerFaceSvg(QRCode.create(i.qr, { errorCorrectionLevel: QR_ECC as QRCode.QRCodeErrorCorrectionLevel }).modules, look),
+    );
+    docHtml.value = buildStickerDocument(chosen, faces, { design: look, siteName: siteName.value });
+  },
+  { deep: true },
+);
 
 function print() {
   const win = frame.value?.contentWindow;

package/composables/useInventory.ts

@@ -7,8 +7,10 @@ import { inventoryCaps } from "../utils/inventory-presets";
  * or hide actions from that, never from a guess on the client.
  */
 export default function useInventory() {
+  // `X-Inventory-Ack: 1`: this screen shows the Received step, so the API may hold stock that is not
+  // confirmed yet (API contract 2026-10-03). An API without the step ignores the header.
   const api = <T = any>(url: string, options: Record<string, any> = {}) =>
-    useNuxtApp().$api<T>(`/api/inventory${url}`, options);
+    useNuxtApp().$api<T>(`/api/inventory${url}`, { ...options, headers: { ...(options.headers ?? {}), "X-Inventory-Ack": "1" } });
 
   const typeLabels: Record<string, string> = {
     opening: "Opening stock",
@@ -19,6 +21,7 @@ export default function useInventory() {
     return: "Returned",
     adjust: "Stock count",
     handover: "Hand-over",
+    write_off: "Written off",
   };
 
   return {
@@ -28,8 +31,10 @@ export default function useInventory() {
       ((await api<TInventoryStore[]>("/stores", { query: { site } })) ?? []).map((s) => ({ ...s, access: inventoryCaps(s.access) })),
     createStore: (body: { org: string; sites: string[]; name: string }) =>
       api<TInventoryStore>("/stores", { method: "POST", body }),
-    updateStore: (id: string, body: Partial<Pick<TInventoryStore, "name" | "sites" | "showInResidentApp" | "showCostInResidentApp">>) =>
+    updateStore: (id: string, body: Partial<Pick<TInventoryStore, "name" | "sites" | "showInResidentApp" | "showCostInResidentApp" | "lowStockReminderDays">>) =>
       api<TInventoryStore>(`/stores/${id}`, { method: "PATCH", body }),
+    /** One store with its settings (`lowStockReminderDays` only from an API that sends reminders). */
+    getStore: (id: string) => api<TInventoryStore>(`/stores/${id}`),
 
     getItems: (store: string, query: { page?: number; limit?: number; search?: string; lowStock?: boolean; includeInactive?: boolean; usedBy?: string }) =>
       api<{ items: TInventoryItem[]; total: number; lowCount: number; page: number; pages: number }>(`/stores/${store}/items`, { query }),
@@ -46,8 +51,9 @@ export default function useInventory() {
     receiveReturn: (store: string, body: Record<string, any>) => api(`/stores/${store}/returns`, { method: "POST", body }),
     recordUsage: (store: string, body: Record<string, any>) => api(`/stores/${store}/usage`, { method: "POST", body }),
     /** Usage drafts: before photo now, after photo and submit after the job (stock is deducted on submit). */
-    getUsageDrafts: (store: string, everyone = false) =>
-      api<{ items: TInventoryUsageDraft[]; staleAfterDays: number }>(`/stores/${store}/usage-drafts`, { query: everyone ? { everyone: true } : {} }),
+    /** Own drafts; "colleagues" = same-company colleagues' open drafts (anyone who records usage); "everyone" = supervisors. */
+    getUsageDrafts: (store: string, scope: "" | "colleagues" | "everyone" = "") =>
+      api<{ items: TInventoryUsageDraft[]; staleAfterDays: number }>(`/stores/${store}/usage-drafts`, { query: scope ? { [scope]: true } : {} }),
     createUsageDraft: (store: string, body: Record<string, any>) => api<TInventoryUsageDraft>(`/stores/${store}/usage-drafts`, { method: "POST", body }),
     updateUsageDraft: (id: string, body: Record<string, any>) => api<TInventoryUsageDraft>(`/usage-drafts/${id}`, { method: "PATCH", body }),
     discardUsageDraft: (id: string) => api(`/usage-drafts/${id}/discard`, { method: "POST" }),
@@ -60,12 +66,24 @@ export default function useInventory() {
       api(`/requests/${id}/approve`, { method: "POST", body }),
     rejectRequest: (id: string, remarks: string) => api(`/requests/${id}/reject`, { method: "POST", body: { remarks } }),
     cancelRequest: (id: string) => api(`/requests/${id}/cancel`, { method: "POST" }),
+    /** The person confirms the issued stock reached them (or did not, with a reason). */
+    acknowledgeRequest: (id: string) => api<TInventoryRequest>(`/requests/${id}/acknowledge`, { method: "POST", body: {} }),
+    notReceived: (id: string, reason: string) => api<TInventoryRequest>(`/requests/${id}/not-received`, { method: "POST", body: { reason } }),
+    /** Used up / spoilt / damaged / lost / other: from the person's own stock, or from the store shelf (store keeper). */
+    writeOff: (store: string, body: { from: "holding" | "store"; site?: string; item: string; qty: number; reason: string; remarks?: string; photos?: string[] }) =>
+      api<TInventoryTransaction>(`/stores/${store}/write-offs`, { method: "POST", body }),
+    /** The holder asks to give stock back; a store keeper accepts it (acceptHandover) when it arrives. */
+    requestReturn: (store: string, body: { site: string; item: string; qty: number; note?: string }) =>
+      api<TInventoryHandover>(`/stores/${store}/returns/request`, { method: "POST", body }),
+    takeOverDraft: (id: string) => api<TInventoryUsageDraft>(`/usage-drafts/${id}/take-over`, { method: "POST", body: {} }),
+    acknowledgeLowStock: (itemId: string, poNumber = "") =>
+      api<TInventoryItem>(`/items/${itemId}/low-stock/acknowledge`, { method: "POST", body: poNumber ? { poNumber } : {} }),
 
     getHoldings: (store: string, holder: string = "me", includeUsedUp = false) =>
       api<TInventoryHolding[]>(`/stores/${store}/holdings`, { query: { holder, ...(includeUsedUp ? { includeUsedUp: true } : {}) } }),
     /** Give to colleague. */
     getHandovers: (store: string, query: { mine?: boolean; status?: string; item?: string; page?: number; limit?: number }) =>
-      api<{ items: TInventoryHandover[]; total: number; waitingForMe: number }>(`/stores/${store}/handovers`, { query }),
+      api<{ items: TInventoryHandover[]; total: number; waitingForMe: number; returnsWaiting?: number }>(`/stores/${store}/handovers`, { query }),
     createHandover: (store: string, body: { site: string; item: string; to: string; qty: number; note?: string; photos?: string[] }) =>
       api<TInventoryHandover>(`/stores/${store}/handovers`, { method: "POST", body }),
     acceptHandover: (id: string) => api(`/handovers/${id}/accept`, { method: "POST" }),
@@ -82,7 +100,7 @@ export default function useInventory() {
     getPeople: (store: string, search = "") =>
       api<{ _id: string; name: string; orgName: string; email?: string; company?: string; service?: string; serviceLabel?: string; label?: string }[]>(`/stores/${store}/people`, { query: { search } }),
 
-    getReport: (store: string, report: "movement" | "usage" | "technicians" | "purchases" | "handovers", query: TInventoryPeriod & Record<string, any>) =>
+    getReport: (store: string, report: "movement" | "usage" | "technicians" | "purchases" | "handovers" | "reconciliation", query: TInventoryPeriod & Record<string, any>) =>
       api<{ rows: any[]; totalQty?: number; totalCost?: number; scope?: "all" | "own_company"; staleAfterDays?: number }>(`/stores/${store}/reports/${report}`, { query }),
     /** One PO across all its deliveries: ordered vs received per item (report viewers and store keepers). */
     getPurchaseOrder: (store: string, po: string) =>

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "4.94.0",
+  "version": "4.96.0",
   "author": "7365admin1",
   "main": "./nuxt.config.ts",
   "//files": "What a consumer extending this layer actually loads. Without this npm ships the whole working tree - the changesets, the CI workflows, the render harness in tools/ and any scratch directory that happened to exist at publish time. Nuxt resolves a layer by directory, so every runtime directory below has to stay listed; adding a new top-level runtime directory means adding it here too.",

package/types/inventory.d.ts

@@ -30,6 +30,8 @@ declare type TInventoryStore = {
   ownerService?: string | null;
   /** "Property management", "M&E", ... */
   ownerServiceLabel?: string;
+  /** Low-stock reminders every N days until a PO is recorded (0 = off). Only from GET /stores/:id of an API that sends them. */
+  lowStockReminderDays?: number;
 };
 
 declare type TInventoryItem = {
@@ -49,6 +51,22 @@ declare type TInventoryItem = {
   lowStock: boolean;
   /** Main store: which service providers see and may request it (["all"] or service keys). */
   usedBy?: string[];
+  /** Set aside by pending requests (2026-10-03); `available` = onHand - reserved. Missing on an older API. */
+  reserved?: number;
+  available?: number;
+  /** Issued but not yet confirmed (Received) by the person. */
+  awaitingReceipt?: number;
+  /** Only while the item is low. */
+  lowStockAlert?: {
+    since?: string;
+    nextRemindAt?: string | null;
+    lastRemindedAt?: string;
+    acknowledgedByName?: string;
+    acknowledgedAt?: string;
+    poNumber?: string;
+    poRecordedByName?: string;
+    poRecordedAt?: string;
+  };
 };
 
 declare type TInventoryLine = { item: string; qty: number };
@@ -60,7 +78,7 @@ declare type TInventoryRequest = {
   siteName?: string;
   requestedBy: string;
   requestedByName: string;
-  lines: { item: string; itemName: string; unit: string; qty: number; issuedQty: number }[];
+  lines: { item: string; itemName: string; unit: string; qty: number; issuedQty: number; reservedQty?: number }[];
   reference: string;
   remarks: string;
   status: "pending" | "issued" | "rejected" | "cancelled";
@@ -68,6 +86,13 @@ declare type TInventoryRequest = {
   decidedAt?: string;
   decisionRemarks?: string;
   createdAt: string;
+  requestedByLabel?: string;
+  /** Receipt step (missing = received, as before). */
+  ackStatus?: "awaiting" | "received" | "not_received";
+  acknowledgedAt?: string;
+  acknowledgedVia?: "app" | "auto";
+  notReceivedAt?: string;
+  notReceivedReason?: string;
 };
 
 declare type TInventoryHolding = {
@@ -87,6 +112,8 @@ declare type TInventoryHolding = {
   inDrafts?: number;
   draftCount?: number;
   free?: number;
+  /** Issued but not yet confirmed with Received: locked until then. */
+  unacknowledged?: number;
 };
 
 declare type TInventoryTransaction = {
@@ -94,7 +121,7 @@ declare type TInventoryTransaction = {
   item: string;
   itemName: string;
   unit: string;
-  type: "opening" | "receive" | "issue" | "use" | "return" | "adjust" | "handover" | "use_draft";
+  type: "opening" | "receive" | "issue" | "use" | "return" | "adjust" | "handover" | "use_draft" | "write_off";
   qty: number;
   storeChange: number;
   storeBalance: number;
@@ -128,6 +155,13 @@ declare type TInventoryTransaction = {
   photosBeforeAt?: string | null;
   photosAfterAt?: string | null;
   submittedAt?: string;
+  writeOffReason?: string;
+  /** "Also attended" on a usage record. */
+  attendedWith?: string;
+  /** A draft taken over from a colleague. */
+  startedBy?: string;
+  startedByName?: string;
+  takenOverAt?: string;
 };
 
 /** A usage record saved with its before photo, waiting for the after photo (no stock deducted yet). */
@@ -169,6 +203,9 @@ declare type TInventoryHandover = {
   declineReason?: string;
   createdAt: string;
   decidedAt?: string;
+  /** "return": the holder giving stock back to the store (`to` empty, `toName` = the store). */
+  kind?: "return";
+  decidedByName?: string;
 };
 
 /** GET /stores/:id/reports/purchase-order: one item of a PO, ordered (null = not recorded) vs received. */

package/utils/inventory-ack.ts

@@ -0,0 +1,172 @@
+/**
+ * Inventory words for the October 2026 steps (owner 2026-10-03): stock set aside at request time,
+ * the person tapping Received / Not received, write-offs, returns started by the holder, low-stock
+ * reminders and the reconciliation check. Browser-safe, no Nuxt imports, so the tests run on node.
+ *
+ * Every new field is optional: an API without these steps (production before the release) leaves
+ * them out and the screens fall back to what they showed before.
+ */
+
+/** The store answers with its reminder setting only once these steps exist on the server. */
+export function inventoryStepsLive(store?: { lowStockReminderDays?: number | null } | null) {
+  return typeof store?.lowStockReminderDays === "number";
+}
+
+/** Singular / plural of the item units the store offers; any other unit is shown as typed. */
+const UNIT_FORMS: Record<string, [string, string]> = {
+  pc: ["pc", "pcs"], pcs: ["pc", "pcs"], box: ["box", "boxes"], boxes: ["box", "boxes"], set: ["set", "sets"], sets: ["set", "sets"],
+  pack: ["pack", "packs"], packs: ["pack", "packs"], roll: ["roll", "rolls"], rolls: ["roll", "rolls"], can: ["can", "cans"], cans: ["can", "cans"],
+  bottle: ["bottle", "bottles"], bottles: ["bottle", "bottles"], litre: ["litre", "litres"], litres: ["litre", "litres"],
+  metre: ["metre", "metres"], metres: ["metre", "metres"],
+};
+
+/** "1 pc", "2 pcs", "1 box", "3 boxes"; kg and unknown units unchanged. */
+export function qtyUnit(qty: number | string | null | undefined, unit?: string | null) {
+  const forms = UNIT_FORMS[String(unit ?? "").trim().toLowerCase()];
+  const word = forms ? forms[Math.abs(Number(qty)) === 1 ? 0 : 1] : (unit ?? "");
+  return `${qty ?? ""} ${word}`.trim();
+}
+
+/** "you hold 2 pcs" or, while some still wait for Received, "you hold 2 pcs (2 waiting for you to tap Received)". */
+export function holdText(h: { qty?: number; unit?: string; unacknowledged?: number } | null | undefined) {
+  const locked = Math.min(Number(h?.unacknowledged ?? 0), Number(h?.qty ?? 0));
+  return `you hold ${qtyUnit(h?.qty ?? 0, h?.unit)}${locked > 0 ? ` (${locked} waiting for you to tap Received)` : ""}`;
+}
+
+/** What can still be requested: `available` from the API, else what is on the shelf. */
+export function availableQty(item: { onHand: number; available?: number }) {
+  return item.available ?? item.onHand;
+}
+
+/** "Available: 8 pcs · 2 set aside for requests". */
+export function availableText(item: { onHand: number; available?: number; reserved?: number; unit: string }) {
+  const reserved = item.reserved ?? 0;
+  return `Available: ${qtyUnit(availableQty(item), item.unit)}${reserved > 0 ? ` · ${reserved} set aside for requests` : ""}`;
+}
+
+/**
+ * The most a store keeper can give on one request line: what is free, plus what this request
+ * itself set aside (it is already counted out of "available").
+ */
+export function approveCap(item: { onHand: number; available?: number } | undefined, reservedByThisRequest = 0) {
+  if (!item) return undefined;
+  if (item.available === undefined) return item.onHand;
+  return Math.min(item.onHand, item.available + reservedByThisRequest);
+}
+
+export type TAck = "awaiting" | "received" | "not_received";
+type TAckRequest = { status: string; ackStatus?: TAck; acknowledgedVia?: string; notReceivedReason?: string; requestedByName?: string };
+
+/** The receipt step of an approved request, as one plain line; "" when there is nothing to say. */
+export function ackText(r: TAckRequest, mine: boolean) {
+  if (r.status !== "issued" || !r.ackStatus) return "";
+  const who = r.requestedByName || "the person";
+  if (r.ackStatus === "awaiting")
+    return mine
+      ? "Handed over to you. Tap Received once the items are in your hands, or Not received if you did not get them. You can use the items after you tap Received."
+      : `Waiting for ${who} to tap Received. They get a reminder every day until they do.`;
+  if (r.ackStatus === "not_received")
+    return mine
+      ? `You said you did not receive this${r.notReceivedReason ? ` ("${r.notReceivedReason}")` : ""}. The store keeper has been told and will follow up. Got it after all? Tap Received.`
+      : `${who} says they did NOT receive this${r.notReceivedReason ? `: "${r.notReceivedReason}"` : ""}. Please check. If it was not handed over, use Receive return next to their name (staff tab) to put it back in the store.`;
+  return r.acknowledgedVia === "auto" ? "" : mine ? "You confirmed you received this." : `${who} confirmed receiving it.`;
+}
+
+export const ACK_CHIP: Record<TAck, { label: string; color: string }> = {
+  awaiting: { label: "Waiting for Received", color: "warning" },
+  not_received: { label: "Not received", color: "error" },
+  received: { label: "Received", color: "success" },
+};
+
+/** Write-off reasons: the API's value, the words on screen. */
+export const WRITE_OFF_REASONS = [
+  { value: "expended", title: "Used up" },
+  { value: "spoilt", title: "Spoilt" },
+  { value: "damaged", title: "Damaged" },
+  { value: "lost", title: "Lost" },
+  { value: "other", title: "Other" },
+] as const;
+export type TWriteOffReason = (typeof WRITE_OFF_REASONS)[number]["value"];
+
+/** A store keeper writing off from the shelf picks the reason (nothing chosen first); a holder starts on "Used up". */
+export const writeOffDefaultReason = (from: "holding" | "store") => (from === "store" ? "" : "expended");
+
+export const writeOffLabel = (reason?: string) => WRITE_OFF_REASONS.find((r) => r.value === reason)?.title ?? (reason || "");
+
+/** The same sentence the API uses, shown before saving. */
+export function writeOffProblem(input: { reason: string; remarks: string }) {
+  if (!input.reason) return "Choose why the stock is being written off.";
+  if (input.reason === "other" && !input.remarks.trim()) return "Say what happened (remarks) when the reason is Other.";
+  return "";
+}
+
+/** `{ expended: 5, spoilt: 2 }` -> "5 used up, 2 spoilt" (reasons with 0 left out). */
+export function writeOffReasonText(byReason?: Record<string, number> | null, unit = "") {
+  return Object.entries(byReason ?? {})
+    .filter(([, n]) => n > 0)
+    .map(([reason, n]) => `${qtyUnit(n, unit)} ${writeOffLabel(reason).toLowerCase()}`)
+    .join(", ");
+}
+
+type TLowStockAlert = {
+  since?: string;
+  acknowledgedByName?: string;
+  acknowledgedAt?: string;
+  poNumber?: string;
+  poRecordedByName?: string;
+};
+
+/** The line under a low item: since when, who saw it, and whether reminders still go out. */
+export function lowStockAlertText(alert: TLowStockAlert | null | undefined, formatDay: (d: string) => string) {
+  if (!alert) return "";
+  const parts = [alert.since ? `Low since ${formatDay(alert.since)}` : "Low on stock"];
+  if (alert.poNumber) parts.push(`PO ${alert.poNumber} recorded${alert.poRecordedByName ? ` by ${alert.poRecordedByName}` : ""} - reminders stopped`);
+  else if (alert.acknowledgedByName) parts.push(`Seen by ${alert.acknowledgedByName} - reminders continue until a PO number is recorded`);
+  else parts.push("Not acknowledged yet");
+  return parts.join(" · ");
+}
+
+/** Store Settings: what the reminder number means. */
+export function reminderDaysText(days: number | null | undefined) {
+  const n = Number(days ?? 1);
+  if (!n) return "Off: one alert when an item goes low, no reminders.";
+  return `Store staff are reminded ${n === 1 ? "every day" : `every ${n} days`} about low items until someone records a PO number for them.`;
+}
+
+/** Reconciliation: one person's line for an item in plain words. */
+export function reconciliationPersonText(p: {
+  opening: number;
+  taken: number;
+  fromColleagues: number;
+  toColleagues: number;
+  used: number;
+  usedWhere?: { where: string; reference?: string; qty: number }[];
+  writtenOff: number;
+  writtenOffByReason?: Record<string, number>;
+  returned: number;
+  closing: number;
+  awaitingReceipt?: number;
+}, unit: string) {
+  const parts: string[] = [];
+  if (p.opening) parts.push(`had ${p.opening} at the start`);
+  if (p.taken) parts.push(`took ${p.taken}`);
+  if (p.fromColleagues) parts.push(`got ${p.fromColleagues} from colleagues`);
+  if (p.used) {
+    const where = (p.usedWhere ?? []).map((w) => `${w.qty} at ${w.where}${w.reference ? ` (${w.reference})` : ""}`).join(", ");
+    parts.push(`used ${p.used}${where ? `: ${where}` : ""}`);
+  }
+  if (p.writtenOff) parts.push(writeOffReasonText(p.writtenOffByReason) || `${p.writtenOff} written off`);
+  if (p.toColleagues) parts.push(`gave ${p.toColleagues} to colleagues`);
+  if (p.returned) parts.push(`returned ${p.returned} to the store`);
+  parts.push(`holds ${qtyUnit(p.closing, unit)}`);
+  if (p.awaitingReceipt) parts.push(`${p.awaitingReceipt} not yet confirmed as received`);
+  return parts.join(" · ");
+}
+
+/** Reconciliation check, in words a store keeper can act on. */
+export function reconciliationCheckText(check: { in: number; out: number; ok: boolean } | null | undefined) {
+  if (!check) return "";
+  return check.ok
+    ? `Tallies: ${check.in} in = ${check.out} accounted for.`
+    : `Does not tally: ${check.in} in, ${check.out} accounted for. Please do a stock count, or ask Seven365 support to check this item.`;
+}

package/utils/inventory-request-text.ts

@@ -3,6 +3,8 @@
  * words, how many were handed over against how many were asked, and who
  * decided and when. Used by `InventoryRequestsTab`.
  */
+import { qtyUnit } from "./inventory-ack.ts";
+
 type TLine = { itemName: string; unit: string; qty: number; issuedQty: number };
 type TRequest = { status: string; decidedByName?: string; decidedAt?: string; decisionRemarks?: string };
 
@@ -13,10 +15,10 @@ export const REQUEST_STATUS: Record<string, { label: string; color: string }> =
   cancelled: { label: "Cancelled", color: "grey" },
 };
 
+/** "(asked N)" only when less was handed over than asked; a counter issue was never asked for. */
 export function requestLineText(status: string, l: TLine) {
-  return status === "issued"
-    ? `${l.itemName} — ${l.issuedQty} ${l.unit} handed over (asked ${l.qty})`
-    : `${l.itemName} — ${l.qty} ${l.unit}`;
+  if (status !== "issued") return `${l.itemName} — ${qtyUnit(l.qty, l.unit)}`;
+  return `${l.itemName} — ${qtyUnit(l.issuedQty, l.unit)} handed over${l.issuedQty !== l.qty ? ` (asked ${l.qty})` : ""}`;
 }
 
 /** "Approved and handed over by X on <when> — remarks", or "" before a decision. */

package/utils/inventory-usage.ts

@@ -36,6 +36,17 @@ export function draftCardText(d: TDraft, time: (iso: string) => string, staleDay
   };
 }
 
+/** "Kevin started this job at Unit 05-12 at 9:40 - take it over to finish it with your own stock." (a colleague's open draft) */
+export function colleagueDraftText(
+  d: { startedByName?: string; holderName?: string; location?: TLocation; reference?: string; draftedAt?: string; photosBeforeAt?: string | null },
+  time: (iso: string) => string,
+) {
+  const who = d.holderName || d.startedByName || "A colleague";
+  const where = whereText(d.location) || d.reference || "";
+  const at = d.draftedAt || d.photosBeforeAt;
+  return `${who} started this job${where ? ` at ${where}` : ""}${at ? ` at ${time(at)}` : ""} - take it over to finish it with your own stock.`;
+}
+
 /** "Issued to Ali by Keeper (29/09) → Handed to Bala by Ali (29/09)". */
 export function usagePathText(steps: TStep[] | undefined, day: (iso: string) => string) {
   if (!steps?.length) return "";
@@ -71,9 +82,13 @@ export function usageTotals(rows: { status?: string; qty: number; totalCost?: nu
   };
 }
 
+const WRITE_OFF_WORDS: Record<string, string> = { expended: "used up", spoilt: "spoilt", damaged: "damaged", lost: "lost", other: "other" };
+
 /** What a history row says happened, from the person's side. */
-export function historyText(t: { type: string; holderChange?: number }) {
+export function historyText(t: { type: string; holderChange?: number; writeOffReason?: string }) {
   switch (t.type) {
+    case "write_off":
+      return `Written off${t.writeOffReason ? ` (${WRITE_OFF_WORDS[t.writeOffReason] ?? t.writeOffReason})` : ""}${(t.holderChange ?? 0) < 0 ? "" : " from the store"}`;
     case "issue":
       return "Taken from store";
     case "return":

package/utils/notification-target.ts

@@ -45,7 +45,7 @@ export type TTargetRow = {
    * (core `withNotificationKind`); `site` stands in for `siteId` on rows kept
    * unscoped on purpose. Older rows have neither and are read from `module`.
    */
-  params?: { id?: string; org?: string; kind?: string; site?: string; storeId?: string } | null;
+  params?: { id?: string; org?: string; kind?: string; site?: string; storeId?: string; requestId?: string } | null;
 };
 
 /** What the surrounding app knows that the stored row does not. */
@@ -144,7 +144,7 @@ export function notificationKind(item: TTargetRow | null | undefined): string {
  */
 export function inventoryTabForAlert(title: string): "requests" | "stock" | "mine" | "" {
   if (/stock handed to you|hand-over (confirmed|declined)/i.test(title)) return "mine";
-  if (/request waiting|request (was )?(approved|rejected)/i.test(title)) return "requests";
+  if (/request waiting|request (was )?(approved|rejected)|confirm you received/i.test(title)) return "requests";
   if (/low (on )?stock/i.test(title)) return "stock";
   return "";
 }
@@ -237,7 +237,13 @@ function sitePageTarget(
   // Open the alert's own store on the tab it is about (InventoryMain reads ?storeId=&tab=).
   const storeId = String(item.params?.storeId ?? item.params?.id ?? "").trim();
   const tab = inventoryTabForAlert(String(item.title ?? ""));
-  const query: Record<string, string> = { ...(storeId ? { storeId } : {}), ...(tab ? { tab } : {}) };
+  // Approved / please confirm / reminder alerts name their request (API 2026-10-03): open that request.
+  const requestId = String(item.params?.requestId ?? "").trim();
+  const query: Record<string, string> = {
+    ...(storeId ? { storeId } : {}),
+    ...(tab || requestId ? { tab: tab || "requests" } : {}),
+    ...(requestId ? { requestId } : {}),
+  };
   return Object.keys(query).length ? { candidates, query } : { candidates };
 }