@7365admin1/layer-common 4.90.2-staging.492 → 4.90.2-staging.494

package/components/InventoryUsageDialog.vue

@@ -92,6 +92,18 @@
 
           <InputLabel :title="draft ? 'Date of the job (used when you submit)' : 'Date used'" class="mb-1 mt-3" />
           <v-text-field v-model="date" type="date" :max="today" density="comfortable" style="max-width: 200px" />
+          <template v-if="stepsLive">
+            <InputLabel title="Also attended (optional)" class="mb-1" />
+            <v-text-field
+              v-model="attendedWith"
+              density="comfortable"
+              maxlength="200"
+              placeholder="e.g. Ahmad, Kumar"
+              hint="Colleagues who did this job with you. The stock still comes from your own stock."
+              persistent-hint
+              class="mb-2"
+            />
+          </template>
           <InputLabel title="Fault reported by (optional)" class="mb-1" />
           <v-text-field v-model="reportedBy" density="comfortable" placeholder="e.g. tenant, security guard" maxlength="120" />
           <InputLabel title="Remarks (optional)" class="mb-1" />
@@ -122,6 +134,7 @@
 <script setup lang="ts">
 import useInventory, { pickedDate } from "../composables/useInventory";
 import useUtils from "../composables/useUtils";
+import { inventoryStepsLive } from "../utils/inventory-ack";
 
 const show = defineModel<boolean>({ default: false });
 const props = defineProps({
@@ -155,6 +168,8 @@ const area = ref("");
 const reference = ref("");
 const remarks = ref("");
 const reportedBy = ref("");
+const attendedWith = ref("");
+const stepsLive = computed(() => inventoryStepsLive(props.store));
 const date = ref(today);
 const photosBefore = ref<string[]>([]);
 const photosAfter = ref<string[]>([]);
@@ -199,6 +214,8 @@ function body() {
     photosAfter: photosAfter.value,
     remarks: remarks.value,
     reportedBy: reportedBy.value,
+    // Only to an API that knows it (an older one refuses an unknown field).
+    ...(stepsLive.value && attendedWith.value.trim() ? { attendedWith: attendedWith.value.trim() } : {}),
   };
 }
 
@@ -282,6 +299,7 @@ watch(show, (open) => {
   reference.value = "";
   remarks.value = "";
   reportedBy.value = "";
+  attendedWith.value = "";
   date.value = today;
   site.value = props.store.sites.includes(props.siteId) ? props.siteId : props.store.sites[0];
   const d = props.draft;
@@ -297,6 +315,7 @@ watch(show, (open) => {
     reference.value = d.reference ?? "";
     remarks.value = d.remarks ?? "";
     reportedBy.value = d.reportedBy ?? "";
+    attendedWith.value = d.attendedWith ?? "";
     photosBefore.value = [...(d.photos?.before ?? [])];
     photosAfter.value = [...(d.photos?.after ?? [])];
     nextTick(() => (prefilling = false));

package/components/InventoryWriteOffDialog.vue

@@ -0,0 +1,110 @@
+<template>
+  <v-dialog v-model="show" max-width="560" persistent scrollable>
+    <v-card class="screen-modal">
+      <v-card-title class="d-flex align-center">
+        Write off {{ itemName }}
+        <v-spacer />
+        <v-btn icon="mdi-close" variant="text" class="screen-modal__close" aria-label="Close" @click="show = false" />
+      </v-card-title>
+      <v-card-text class="screen-modal__body">
+        <p class="text-body-2 text-medium-emphasis mb-3">
+          {{
+            from === "store"
+              ? `For stock on the store shelf that can no longer be used. ${max} ${unit} on the shelf.`
+              : `For stock in your hands that is used up, spoilt, damaged or lost. It does not go back to the store and is not counted as usage. You can write off up to ${max} ${unit}.`
+          }}
+        </p>
+        <v-form ref="form">
+          <InputLabel title="How many?" required class="mb-1" />
+          <v-text-field
+            v-model.number="qty"
+            type="number"
+            min="1"
+            :max="max"
+            density="comfortable"
+            :suffix="unit"
+            style="max-width: 200px"
+            :rules="[(v: any) => (Number.isInteger(Number(v)) && Number(v) >= 1) || 'Enter a whole number', (v: any) => Number(v) <= max || `You can write off up to ${max}`]"
+          />
+          <InputLabel title="Why?" required class="mb-1" />
+          <v-chip-group v-model="reason" mandatory selected-class="text-primary" class="mb-2">
+            <v-chip v-for="r in WRITE_OFF_REASONS" :key="r.value" :value="r.value" variant="outlined" filter>{{ r.title }}</v-chip>
+          </v-chip-group>
+          <InputLabel :title="reason === 'other' ? 'What happened?' : 'Remarks (optional)'" :required="reason === 'other'" class="mb-1" />
+          <v-textarea v-model="remarks" rows="2" auto-grow density="comfortable" maxlength="1000" placeholder="e.g. fell into the drain at block 3" />
+          <InputLabel title="Photos (optional)" class="mb-1" />
+          <InventoryPhotoInput v-model="photos" :max="5" />
+          <v-alert v-if="problem" type="warning" variant="tonal" density="compact" class="mt-2">{{ problem }}</v-alert>
+        </v-form>
+      </v-card-text>
+      <div class="screen-modal__footer">
+        <v-btn class="screen-btn-ghost" variant="outlined" :disabled="saving" @click="show = false">Cancel</v-btn>
+        <v-btn class="screen-btn-primary" variant="flat" :loading="saving" @click="save">Write off</v-btn>
+      </div>
+    </v-card>
+  </v-dialog>
+</template>
+
+<script setup lang="ts">
+import useInventory from "../composables/useInventory";
+import { WRITE_OFF_REASONS, writeOffLabel, writeOffProblem } from "../utils/inventory-ack";
+
+/** Write-off (owner 2026-10-03): from the person's own stock (`holding`) or, for a store keeper, from the shelf (`store`). */
+const show = defineModel<boolean>({ default: false });
+const props = defineProps({
+  store: { type: Object as PropType<TInventoryStore>, required: true },
+  from: { type: String as PropType<"holding" | "store">, default: "holding" },
+  item: { type: String, default: "" },
+  itemName: { type: String, default: "" },
+  unit: { type: String, default: "" },
+  max: { type: Number, default: 0 },
+  siteId: { type: String, default: "" },
+});
+const emit = defineEmits(["done"]);
+
+const api = useInventory();
+const notify = inject<(text: string, color?: string) => void>("inventoryNotify", () => {});
+
+const form = ref();
+const qty = ref<number | null>(1);
+const reason = ref("expended");
+const remarks = ref("");
+const photos = ref<string[]>([]);
+const saving = ref(false);
+const tried = ref(false);
+const problem = computed(() => (tried.value ? writeOffProblem({ reason: reason.value ?? "", remarks: remarks.value }) : ""));
+
+async function save() {
+  tried.value = true;
+  const { valid } = await form.value.validate();
+  if (!valid || writeOffProblem({ reason: reason.value ?? "", remarks: remarks.value })) return;
+  saving.value = true;
+  try {
+    await api.writeOff(props.store._id, {
+      from: props.from,
+      ...(props.siteId && props.store.sites.includes(props.siteId) ? { site: props.siteId } : {}),
+      item: props.item,
+      qty: Number(qty.value),
+      reason: reason.value,
+      remarks: remarks.value.trim(),
+      photos: photos.value,
+    });
+    notify(`${qty.value} ${props.unit} of ${props.itemName} written off as ${writeOffLabel(reason.value).toLowerCase()}.${props.from === "holding" ? " The store keeper has been told." : ""}`);
+    show.value = false;
+    emit("done");
+  } catch (error: any) {
+    notify(error?.data?.message || "Could not write it off. Please try again.", "error");
+  } finally {
+    saving.value = false;
+  }
+}
+
+watch(show, (open) => {
+  if (!open) return;
+  qty.value = 1;
+  reason.value = "expended";
+  remarks.value = "";
+  photos.value = [];
+  tried.value = false;
+});
+</script>

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.90.2-staging.492",
+  "version": "4.90.2-staging.494",
   "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,148 @@
+/**
+ * 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";
+}
+
+/** 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: ${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"];
+
+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]) => `${n}${unit ? ` ${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 ${p.closing} ${unit}`.trim());
+  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-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 };
 }