diff --git a/CONCEPTS.md b/CONCEPTS.md
index 08d78283..cabbaed1 100644
--- a/CONCEPTS.md
+++ b/CONCEPTS.md
@@ -29,11 +29,11 @@ A single logged range trip for one Firearm — the date and the rounds fired tha
 
 ### Inventory Log
 
-An append-only history of physical-handling events on a single Firearm or Magazine — each **Log Entry** records an **Event Type**, the acting user, when it happened, and optional notes. A **child record** family: entries inherit their parent's owner and grants, cannot be shared on their own, and are removed with the parent. Entries are created and listed but not edited or deleted.
+An append-only history of physical-handling events on a single Firearm or Magazine — each **Log Entry** records an **Event Type**, the acting user, when it happened, and optional notes. A **child record** family: entries inherit their parent's owner and grants, cannot be shared on their own, and are removed with the parent. Entries are created and listed but not edited or deleted. `cleaned` and `lubed` were retired as Firearm Event Types once **Service Event** shipped (service-intervals plan, U5) — logging service against a **Service Rule** is now the single way to record either act; every prior `cleaned`/`lubed` entry converted to a Service Event and the Inventory Log now carries only `inventoried` for both parent families.
 
 ### Event Type
 
-The controlled kind of a **Log Entry** (*inventoried* for any item; *cleaned*, *lubed* for Firearms), drawn from a fixed value set whose valid members depend on the parent family. Deliberately not called an "action" — that name already means a Firearm's operating mechanism (see **Firearm Action**).
+The controlled kind of a **Log Entry** — currently *inventoried*, the only member for either parent family — drawn from a fixed value set whose valid members depend on the parent family. Deliberately not called an "action" — that name already means a Firearm's operating mechanism (see **Firearm Action**).
 
 ### Child record
 
@@ -95,6 +95,16 @@ A short string an owner has used to start Magazine labels. Recorded per owner an
 
 An owner setting that, when on, constrains Magazine labels to what can physically be written in the dot cells of a Magpul magazine floorplate — a limited character set and length. When off, labels are free text.
 
+## Service intervals
+
+### Service Rule
+
+A named maintenance concern tracked against a Firearm or Accessory — Cleaning, Barrel, Recoil spring, and so on — that sets at least one of three thresholds: elapsed days, range sessions, or rounds fired. An item's Service Rules come from its owner's category defaults, live: each is *inherited*, *overridden* with the item's own thresholds, or *suppressed* (removed from the item entirely); an item may also carry *item-only* rules no default defines. A Service Rule belongs to its item's Owner, so a shared item's rules come from the owner's defaults, never the viewer's.
+
+### Service Event
+
+A single logged act of service against one Service Rule — the date it happened, the acting user, and optional notes. Logging a Service Event sets that rule's measurement point: elapsed days, sessions, and rounds all start counting fresh from it. A Firearm or Accessory's service history is every Service Event against it, newest first.
+
 ## Derived values
 
 ### Total Capacity
@@ -113,6 +123,10 @@ The derived state of an **Ammo** lot whose quantity in rounds is at or under its
 
 A Magazine's most recent physical-count date: the `occurredAt` of the latest **Inventory Log** entry with **Event Type** `inventoried`. Derived, not stored — and blank (a first-class state) when the Magazine has never been inventoried. Respects owner-scoping: derived only from entries visible through the parent Magazine.
 
+### Due
+
+The derived state of a **Service Rule** whose elapsed days, sessions, or rounds fired — measured since its last **Service Event**, or the item's origin date when none exists — meets or exceeds any threshold it sets. Binary, never a severity tier: distance past a threshold is shown as the raw counts, not a "due soon" gradation. Never stored — computed from the resolved rule and its elapsed counts wherever it is shown (item detail panel, `/summary` roll-up, list indicators).
+
 ## Design identity
 
 ### Machined Console
diff --git a/app/(app)/accessories/[id]/__tests__/service-props.test.ts b/app/(app)/accessories/[id]/__tests__/service-props.test.ts
new file mode 100644
index 00000000..7caa4999
--- /dev/null
+++ b/app/(app)/accessories/[id]/__tests__/service-props.test.ts
@@ -0,0 +1,159 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { NotFoundError } from "@/src/auth/errors";
+import * as dueService from "@/src/domain/service-intervals/due-service";
+import * as eventsService from "@/src/domain/service-intervals/events-service";
+import * as rulesService from "@/src/domain/service-intervals/rules-service";
+import { loadAccessoryServiceProps } from "../page";
+
+/**
+ * Unit tests for `loadAccessoryServiceProps` (the accessory detail page's
+ * owner-only service-data loader) — specifically the 404 guard added
+ * alongside the firearm detail page's `asNotFound` (mirrored via
+ * `@/src/lib/as-not-found`).
+ *
+ * Uses `spyOn` on the real `due-service`/`events-service`/`rules-service`
+ * module namespaces rather than `mock.module(...)` on those specifiers:
+ * `rules-service` is ALSO `mock.module`-replaced, with a differently-shaped
+ * export set, by `settings/service/__tests__/actions.test.ts` — a second,
+ * incompatible `mock.module` on the same path from this file would collide
+ * when `bun test app` runs every file in one process (mirrors the same
+ * tradeoff documented in `firearms/__tests__/service-actions.test.ts`).
+ * `spyOn` overrides only the named export on the already-loaded module
+ * object, so it doesn't touch that shared registry.
+ */
+
+const USER_ID = "user-1";
+const ACCESSORY_ID = "accessory-1";
+
+describe("loadAccessoryServiceProps", () => {
+  let getItemDueStateSpy: ReturnType<typeof spyOn>;
+  let listItemRulesSpy: ReturnType<typeof spyOn>;
+  let listServiceHistorySpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    getItemDueStateSpy = spyOn(dueService, "getItemDueState").mockResolvedValue(
+      [],
+    );
+    listItemRulesSpy = spyOn(rulesService, "listItemRules").mockResolvedValue(
+      [],
+    );
+    listServiceHistorySpy = spyOn(
+      eventsService,
+      "listServiceHistory",
+    ).mockResolvedValue([]);
+  });
+
+  // `bun test app` runs every file in one process and Bun's `spyOn`
+  // replacements persist until restored, so an unrestored spy here would leak
+  // into whichever file runs next.
+  afterEach(() => {
+    getItemDueStateSpy.mockRestore();
+    listItemRulesSpy.mockRestore();
+    listServiceHistorySpy.mockRestore();
+  });
+
+  test("a non-owner viewer gets null in every field, without calling any loader", async () => {
+    const result = await loadAccessoryServiceProps(
+      USER_ID,
+      ACCESSORY_ID,
+      false,
+    );
+
+    expect(result).toEqual({
+      serviceRules: null,
+      suppressedServiceRuleNames: null,
+      serviceHistory: null,
+    });
+    expect(getItemDueStateSpy).not.toHaveBeenCalled();
+    expect(listItemRulesSpy).not.toHaveBeenCalled();
+    expect(listServiceHistorySpy).not.toHaveBeenCalled();
+  });
+
+  test("an owner viewer gets the resolved rules, suppressed names, and history on the happy path", async () => {
+    const dueRuleStub = {
+      name: "Cleaning",
+    } as unknown as dueService.RuleDueState;
+    const keptRuleStub = {
+      name: "Cleaning",
+      suppressed: false,
+    } as unknown as rulesService.ServiceRuleRow;
+    const suppressedRuleStub = {
+      name: "Lube",
+      suppressed: true,
+    } as unknown as rulesService.ServiceRuleRow;
+    getItemDueStateSpy.mockResolvedValue([dueRuleStub]);
+    listItemRulesSpy.mockResolvedValue([keptRuleStub, suppressedRuleStub]);
+    listServiceHistorySpy.mockResolvedValue([]);
+
+    const result = await loadAccessoryServiceProps(USER_ID, ACCESSORY_ID, true);
+
+    expect(result.serviceRules).toEqual([dueRuleStub]);
+    expect(result.suppressedServiceRuleNames).toEqual(["Lube"]);
+    expect(result.serviceHistory).toEqual([]);
+  });
+
+  // `getItemDueState`/`listItemRules`/`listServiceHistory` route through
+  // `requireAccessoryOwner`, which authorizes internally and can throw
+  // `NotFoundError` if the accessory was deleted or reassigned between the
+  // page's earlier `getAccessory` check and this call. Each loader is
+  // independently exercised so the fix applied to all three isn't only
+  // proven for whichever settles first in the `Promise.all`.
+  const guardedLoaders: Array<{
+    name: string;
+    reject: () => void;
+  }> = [
+    {
+      name: "getItemDueState",
+      reject: () => {
+        getItemDueStateSpy.mockRejectedValue(new NotFoundError());
+      },
+    },
+    {
+      name: "listItemRules",
+      reject: () => {
+        listItemRulesSpy.mockRejectedValue(new NotFoundError());
+      },
+    },
+    {
+      name: "listServiceHistory",
+      reject: () => {
+        listServiceHistorySpy.mockRejectedValue(new NotFoundError());
+      },
+    },
+  ];
+
+  for (const loader of guardedLoaders) {
+    test(`a NotFoundError from ${loader.name} surfaces as Next's clean 404, not an unhandled rejection`, async () => {
+      loader.reject();
+
+      let caught: unknown;
+      try {
+        await loadAccessoryServiceProps(USER_ID, ACCESSORY_ID, true);
+      } catch (error: unknown) {
+        caught = error;
+      }
+
+      // `notFound()` throws a real Next.js error carrying this digest, which
+      // is what the framework's router boundary keys off of to render the
+      // clean 404 UI instead of the generic error boundary.
+      expect(caught).toBeInstanceOf(Error);
+      expect((caught as { digest?: string }).digest).toBe(
+        "NEXT_HTTP_ERROR_FALLBACK;404",
+      );
+    });
+  }
+
+  test("a non-NotFoundError from a loader propagates unchanged, not converted to a 404", async () => {
+    const boom = new Error("boom");
+    getItemDueStateSpy.mockRejectedValue(boom);
+
+    let caught: unknown;
+    try {
+      await loadAccessoryServiceProps(USER_ID, ACCESSORY_ID, true);
+    } catch (error: unknown) {
+      caught = error;
+    }
+
+    expect(caught).toBe(boom);
+  });
+});
diff --git a/app/(app)/accessories/[id]/page.tsx b/app/(app)/accessories/[id]/page.tsx
index 3bcc5ea3..5ef20ee2 100644
--- a/app/(app)/accessories/[id]/page.tsx
+++ b/app/(app)/accessories/[id]/page.tsx
@@ -7,13 +7,75 @@ import { costCentsToInputValue } from "@/src/domain/accessories/display";
 import { getAccessory } from "@/src/domain/accessories/service";
 import { buildFirearmMountContext } from "@/src/domain/firearms/mount-options";
 import { listFirearms } from "@/src/domain/firearms/service";
+import { withActorNames } from "@/src/domain/service-intervals/actor-names";
+import {
+  getItemDueState,
+  type RuleDueState,
+} from "@/src/domain/service-intervals/due-service";
+import { listServiceHistory } from "@/src/domain/service-intervals/events-service";
+import {
+  listItemRules,
+  listOwnerAccessoryCategories,
+} from "@/src/domain/service-intervals/rules-service";
+import { asNotFound } from "@/src/lib/as-not-found";
 import { isUuid } from "@/src/lib/uuid";
+import type { ServiceHistoryEntry } from "../../firearms/service-history";
 import { AccessoryDetailView } from "../accessory-detail-view";
 
 interface PageProps {
   params: Promise<{ id: string }>;
 }
 
+export interface AccessoryServiceProps {
+  serviceRules: RuleDueState[] | null;
+  suppressedServiceRuleNames: string[] | null;
+  serviceHistory: ServiceHistoryEntry[] | null;
+}
+
+/**
+ * Loads service data (U8) for the OWNER only — accessories are owner-only
+ * throughout for service (KTD3), so a non-owner viewer gets `null` in every
+ * field rather than empty arrays, and the detail view doesn't render the
+ * section at all for them (matching `requireAccessoryOwner` throwing were we
+ * to call it for a non-owner anyway).
+ *
+ * Exported so `__tests__/service-props.test.ts` can exercise the 404-guard
+ * race (a loader throwing `NotFoundError` between the page's earlier
+ * `getAccessory` check and this call) directly, without standing up the rest
+ * of the page's dependency graph (`listFirearms`, `visibleFirearmPermissions`,
+ * `AccessoryDetailView`, ...) just to reach it.
+ */
+export async function loadAccessoryServiceProps(
+  userId: string,
+  accessoryId: string,
+  isOwner: boolean,
+): Promise<AccessoryServiceProps> {
+  if (!isOwner) {
+    return {
+      serviceRules: null,
+      suppressedServiceRuleNames: null,
+      serviceHistory: null,
+    };
+  }
+  // These loaders route through `requireAccessoryOwner`, which authorizes
+  // internally and throws `NotFoundError` if the row is deleted or ownership
+  // changes between the page's earlier `getAccessory` check and this call (a
+  // narrow race, mirrors the equivalent guard on the firearm detail page) —
+  // that must surface as the page's clean 404, not an unhandled 500.
+  const [dueRules, itemRules, history] = await Promise.all([
+    getItemDueState(userId, "accessory", accessoryId).catch(asNotFound),
+    listItemRules(userId, "accessory", accessoryId).catch(asNotFound),
+    listServiceHistory(userId, "accessory", accessoryId).catch(asNotFound),
+  ]);
+  return {
+    serviceRules: dueRules,
+    suppressedServiceRuleNames: itemRules
+      .filter((rule) => rule.suppressed)
+      .map((rule) => rule.name),
+    serviceHistory: await withActorNames(history),
+  };
+}
+
 export default async function AccessoryDetailPage({ params }: PageProps) {
   const { id } = await params;
   const user = await getCurrentUser();
@@ -33,15 +95,32 @@ export default async function AccessoryDetailPage({ params }: PageProps) {
     },
   );
 
-  const [firearms, permissions] = await Promise.all([
-    listFirearms(user.id),
-    visibleFirearmPermissions(db, user.id),
-  ]);
+  const isOwner = permission === "owner";
+
+  const [firearms, permissions, serviceProps, ownerCategories] =
+    await Promise.all([
+      listFirearms(user.id),
+      visibleFirearmPermissions(db, user.id),
+      loadAccessoryServiceProps(user.id, id, isOwner),
+      // The ACCESSORY'S OWNER's categories (row.ownerId, not the actor) —
+      // suggestions should reflect the owner whose category defaults (KD10)
+      // this accessory actually inherits from, even when an edit-grantee is
+      // the one editing a shared mount. But `listOwnerAccessoryCategories`
+      // returns EVERY category across ALL of that owner's accessories, not
+      // just the ones visible to this viewer — for a non-owner grantee that
+      // would leak the owner's unrelated-accessory category vocabulary, so
+      // fall back to the actor's own categories instead (still useful
+      // autocomplete, no cross-tenant leak).
+      isOwner
+        ? listOwnerAccessoryCategories(row.ownerId)
+        : listOwnerAccessoryCategories(user.id),
+    ]);
 
   // The reassign-mount picker must offer only firearms owned by the
   // ACCESSORY's owner (`row.ownerId`, not the actor — an edit-grantee acting
   // on someone else's mounted accessory must still only relocate it among
-  // that owner's own guns, KTD5's cross-tenant guard) AND editable by the
+  // that owner's own guns, accessories-tracker plan KTD5's cross-tenant
+  // guard) AND editable by the
   // acting user.
   const { firearmNames, editableFirearms } = buildFirearmMountContext(
     firearms,
@@ -58,6 +137,7 @@ export default async function AccessoryDetailPage({ params }: PageProps) {
         model: row.model,
         serialNumber: row.serialNumber,
         installedDate: row.installedDate ?? "",
+        acquiredDate: row.acquiredDate ?? "",
         cost: costCentsToInputValue(row.costCents),
         notes: row.notes,
         isNfa: row.isNfa,
@@ -66,6 +146,10 @@ export default async function AccessoryDetailPage({ params }: PageProps) {
       permission={permission}
       editableFirearms={editableFirearms}
       firearmNames={firearmNames}
+      serviceRules={serviceProps.serviceRules}
+      suppressedServiceRuleNames={serviceProps.suppressedServiceRuleNames}
+      serviceHistory={serviceProps.serviceHistory}
+      ownerCategories={ownerCategories}
     />
   );
 }
diff --git a/app/(app)/accessories/accessories-view.tsx b/app/(app)/accessories/accessories-view.tsx
index 0a191f35..7a9fcf7c 100644
--- a/app/(app)/accessories/accessories-view.tsx
+++ b/app/(app)/accessories/accessories-view.tsx
@@ -39,6 +39,12 @@ export interface AccessoryListItem {
   notes: string;
   isNfa: boolean;
   currentFirearmId: string | null;
+  /**
+   * True when this accessory itself has at least one due service rule (U9,
+   * R20) — never true merely because the firearm it's mounted to is due.
+   * Advisory only (R21): a marker, not a gate.
+   */
+  serviceDue: boolean;
 }
 
 interface AccessoriesViewProps {
@@ -52,6 +58,9 @@ interface AccessoriesViewProps {
   /** Firearm to pre-select as the mount target, from a firearm detail page's
    * "Add accessory" link (F1). Auto-opens the create form when present. */
   initialMountFirearmId?: string;
+  /** The actor's own previously-typed categories (KTD8-reuse), merged into
+   * the create form's category suggestions — see `AccessoryForm`'s doc. */
+  ownerCategories: string[];
 }
 
 type FormState = { open: false } | { open: true };
@@ -62,6 +71,7 @@ export function AccessoriesView({
   editableFirearms,
   firearmNames,
   initialMountFirearmId,
+  ownerCategories,
 }: AccessoriesViewProps) {
   const router = useRouter();
   // Auto-open the create form pre-mounted to a firearm when arriving from that
@@ -157,6 +167,16 @@ export function AccessoriesView({
         cell: ({ row }) =>
           row.original.isNfa ? <Badge tone="destructive">NFA</Badge> : null,
       },
+      {
+        id: "serviceDue",
+        header: "Service",
+        meta: { label: "Service" },
+        enableSorting: false,
+        cell: ({ row }) =>
+          row.original.serviceDue ? (
+            <Badge tone="destructive">Service due</Badge>
+          ) : null,
+      },
       {
         id: "cost",
         header: "Cost",
@@ -251,6 +271,7 @@ export function AccessoriesView({
           <AccessoryForm
             editableFirearms={editableFirearms}
             initialFirearmId={initialMountFirearmId}
+            ownerCategories={ownerCategories}
             onDone={refresh}
             onCancel={() => setForm({ open: false })}
           />
diff --git a/app/(app)/accessories/accessory-detail-view.tsx b/app/(app)/accessories/accessory-detail-view.tsx
index 4ca2e7d7..21dfe244 100644
--- a/app/(app)/accessories/accessory-detail-view.tsx
+++ b/app/(app)/accessories/accessory-detail-view.tsx
@@ -17,6 +17,12 @@ import {
   formatCostCents,
   parseCostInputToCents,
 } from "@/src/domain/accessories/display";
+import type { RuleDueState } from "@/src/domain/service-intervals/due-service";
+import {
+  ServiceHistory,
+  type ServiceHistoryEntry,
+} from "../firearms/service-history";
+import { ServiceRulesPanel } from "../firearms/service-rules-panel";
 import type { EditableFirearmOption } from "./accessory-form";
 import { AccessoryForm, type AccessoryFormValues } from "./accessory-form";
 import { deleteAccessoryAction, mountAccessoryAction } from "./actions";
@@ -34,6 +40,20 @@ interface AccessoryDetailViewProps {
   /** Display names for every firearm visible to the actor, for the read-only
    * "current firearm" link even when it falls outside `editableFirearms`. */
   firearmNames: Record<string, string>;
+  /**
+   * Service data (U8) — owner-only throughout for accessories (KTD3), so
+   * these are `null` for a non-owner viewer rather than empty: the page
+   * never even loads them in that case (`requireAccessoryOwner` would throw
+   * for a non-owner), and `null` is what tells this view not to render the
+   * section at all, rather than rendering an always-empty panel.
+   */
+  serviceRules: RuleDueState[] | null;
+  suppressedServiceRuleNames: string[] | null;
+  serviceHistory: ServiceHistoryEntry[] | null;
+  /** The ACCESSORY'S OWNER's previously-typed categories (not necessarily
+   * the viewer's, when an edit-grantee is editing a shared mount) — merged
+   * into the edit form's category suggestions, see `AccessoryForm`'s doc. */
+  ownerCategories: string[];
 }
 
 /**
@@ -100,6 +120,10 @@ export function AccessoryDetailView({
   permission,
   editableFirearms,
   firearmNames,
+  serviceRules,
+  suppressedServiceRuleNames,
+  serviceHistory,
+  ownerCategories,
 }: AccessoryDetailViewProps) {
   const router = useRouter();
   const [editing, setEditing] = useState(false);
@@ -179,6 +203,7 @@ export function AccessoryDetailView({
             initial={accessory}
             editableFirearms={editableFirearms}
             currentFirearmId={accessory.currentFirearmId}
+            ownerCategories={ownerCategories}
             onDone={() => {
               setEditing(false);
               router.refresh();
@@ -228,6 +253,10 @@ export function AccessoryDetailView({
               label="Installed date"
               value={orDash(accessory.installedDate)}
             />
+            <DetailRow
+              label="Acquired date"
+              value={orDash(accessory.acquiredDate)}
+            />
             <DetailRow
               label="Cost"
               value={
@@ -254,6 +283,28 @@ export function AccessoryDetailView({
         </Card>
       )}
 
+      {isOwner &&
+      serviceRules !== null &&
+      suppressedServiceRuleNames !== null ? (
+        <ServiceRulesPanel
+          parentType="accessory"
+          parentId={accessory.id}
+          rules={serviceRules}
+          suppressedRuleNames={suppressedServiceRuleNames}
+          canManageRules={isOwner}
+          canLogService={isOwner}
+          onChange={() => router.refresh()}
+        />
+      ) : null}
+
+      {isOwner && serviceHistory !== null ? (
+        <ServiceHistory
+          entries={serviceHistory}
+          canWrite={isOwner}
+          onChange={() => router.refresh()}
+        />
+      ) : null}
+
       <ConfirmDialog
         open={del.target !== null}
         title={`Delete “${displayName}”?`}
diff --git a/app/(app)/accessories/accessory-form.tsx b/app/(app)/accessories/accessory-form.tsx
index 79466b9d..361c5f1f 100644
--- a/app/(app)/accessories/accessory-form.tsx
+++ b/app/(app)/accessories/accessory-form.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { useId, useState, useTransition } from "react";
+import { useId, useMemo, useState, useTransition } from "react";
 import { Button } from "@/components/ui/button";
 import { Callout } from "@/components/ui/feedback";
 import { Field } from "@/components/ui/field";
@@ -27,6 +27,10 @@ export interface AccessoryFormValues {
   serialNumber: string;
   /** ISO date, or `""` when unset. */
   installedDate: string;
+  /** ISO date, or `""` when unset — mirrors `firearm.acquiredDate` (R22),
+   * added during implementation. Unlike `installedDate`, clearing and
+   * re-mounting never touches this field. */
+  acquiredDate: string;
   /** Dollars input string (e.g. `"12.50"`), or `""` when unset — mapped to
    * integer `costCents` on submit (see `parseCostInputToCents`). */
   cost: string;
@@ -40,6 +44,7 @@ const DEFAULTS: AccessoryFormValues = {
   model: "",
   serialNumber: "",
   installedDate: "",
+  acquiredDate: "",
   cost: "",
   notes: "",
   isNfa: false,
@@ -73,6 +78,17 @@ interface AccessoryFormProps {
    * hidden and submits nothing until a mount exists.
    */
   currentFirearmId?: string | null;
+  /**
+   * The owner's own previously-typed categories, alphabetically (KTD8's
+   * `listOwnerAccessoryCategories`, reused here per the plan's deferred-
+   * to-follow-up item) — merged into the category datalist alongside the
+   * static `ACCESSORY_CATEGORY_SUGGESTIONS` so a category the owner already
+   * uses (and that a default set may already key on, KD10) is suggested
+   * before it's retyped with a diverging spelling. Free entry is still fully
+   * permitted — this is suggestion only, never validated membership (KD10
+   * stays exact-string, free text; nothing here rejects an unlisted value).
+   */
+  ownerCategories?: string[];
   /** `touchedId` flashes the just-created/edited row. */
   onDone: (touchedId?: string) => void;
   onCancel: () => void;
@@ -83,6 +99,7 @@ export function AccessoryForm({
   editableFirearms,
   initialFirearmId,
   currentFirearmId,
+  ownerCategories = [],
   onDone,
   onCancel,
 }: AccessoryFormProps) {
@@ -115,11 +132,28 @@ export function AccessoryForm({
   const modelId = useId();
   const serialId = useId();
   const dateId = useId();
+  const acquiredDateId = useId();
   const costId = useId();
   const notesId = useId();
   const nfaId = useId();
   const mountId = useId();
 
+  // Merge the owner's real categories with the static suggestions,
+  // deduplicated, alphabetical after the static list — case-sensitive (KD10
+  // is exact-string matching, so "Optic" and "optic" are deliberately kept
+  // as distinct suggestions rather than folded together).
+  const categorySuggestions = useMemo(() => {
+    const seen = new Set<string>(ACCESSORY_CATEGORY_SUGGESTIONS);
+    const merged: string[] = [...ACCESSORY_CATEGORY_SUGGESTIONS];
+    for (const category of ownerCategories) {
+      if (!seen.has(category)) {
+        seen.add(category);
+        merged.push(category);
+      }
+    }
+    return merged;
+  }, [ownerCategories]);
+
   function set<K extends keyof AccessoryFormValues>(
     key: K,
     value: AccessoryFormValues[K],
@@ -137,6 +171,10 @@ export function AccessoryForm({
       // Hidden/unmounted → submits nothing (R6); the service layer also
       // backstops this on both create and update.
       installedDate: isMounted ? values.installedDate || null : null,
+      // Unlike installedDate, acquiredDate is never gated by mount state —
+      // it records ownership, not mounting — and blanking it persists as
+      // null (clearable), matching firearm.acquiredDate (R22).
+      acquiredDate: values.acquiredDate || null,
     };
     const found = validateAccessory(fields);
     setCodes(found);
@@ -150,6 +188,11 @@ export function AccessoryForm({
         document.getElementById(costId)?.focus();
       } else if (found.includes("invalidInstalledDate")) {
         document.getElementById(dateId)?.focus();
+      } else if (
+        found.includes("invalidAcquiredDate") ||
+        found.includes("acquiredDateInFuture")
+      ) {
+        document.getElementById(acquiredDateId)?.focus();
       }
       return;
     }
@@ -189,7 +232,7 @@ export function AccessoryForm({
     <form onSubmit={submit} className="flex flex-col gap-4" noValidate>
       {serverError ? <Callout tone="destructive">{serverError}</Callout> : null}
       <datalist id="accessory-categories">
-        {ACCESSORY_CATEGORY_SUGGESTIONS.map((c) => (
+        {categorySuggestions.map((c) => (
           <option key={c} value={c} />
         ))}
       </datalist>
@@ -236,6 +279,29 @@ export function AccessoryForm({
       </div>
 
       <div className="grid gap-4 sm:grid-cols-2">
+        {/* Acquired date (R22-parity, added during implementation) — unlike
+            installed date, never gated by mount state: it records ownership,
+            not mounting, so it's always available and always clearable. */}
+        <Field
+          label="Acquired date"
+          controlId={acquiredDateId}
+          hint="Optional"
+          error={firstMessage(codes, [
+            "invalidAcquiredDate",
+            "acquiredDateInFuture",
+          ])}
+        >
+          <Input
+            id={acquiredDateId}
+            type="date"
+            value={values.acquiredDate}
+            onChange={(e) => set("acquiredDate", e.target.value)}
+            aria-invalid={
+              codes.includes("invalidAcquiredDate") ||
+              codes.includes("acquiredDateInFuture")
+            }
+          />
+        </Field>
         {/* Installed date requires a mount (R6) — hidden and submits nothing
             until one exists: the mount select below on create, or the
             accessory's existing mount on edit. */}
@@ -255,6 +321,9 @@ export function AccessoryForm({
             />
           </Field>
         ) : null}
+      </div>
+
+      <div className="grid gap-4 sm:grid-cols-2">
         <Field
           label="Cost"
           controlId={costId}
diff --git a/app/(app)/accessories/page.tsx b/app/(app)/accessories/page.tsx
index afae7f28..cee7d47a 100644
--- a/app/(app)/accessories/page.tsx
+++ b/app/(app)/accessories/page.tsx
@@ -5,6 +5,11 @@ import { db } from "@/src/db/client";
 import { listAccessories } from "@/src/domain/accessories/service";
 import { buildFirearmMountContext } from "@/src/domain/firearms/mount-options";
 import { listFirearms } from "@/src/domain/firearms/service";
+import {
+  dueParentIds,
+  listDueForVisibleCollection,
+} from "@/src/domain/service-intervals/due-service";
+import { listOwnerAccessoryCategories } from "@/src/domain/service-intervals/rules-service";
 import { AccessoriesView, type AccessoryListItem } from "./accessories-view";
 
 interface PageProps {
@@ -17,14 +22,33 @@ export default async function AccessoriesPage({ searchParams }: PageProps) {
 
   const { mountFirearm } = await searchParams;
 
-  const [accessories, firearms, permissions] = await Promise.all([
-    listAccessories(user.id),
-    listFirearms(user.id),
-    visibleFirearmPermissions(db, user.id),
-  ]);
+  const [accessories, firearms, permissions, ownerCategories] =
+    await Promise.all([
+      listAccessories(user.id),
+      listFirearms(user.id),
+      visibleFirearmPermissions(db, user.id),
+      // Suggestions only (KD10 stays exact-string free text) — reuses the
+      // defaults surface's KTD8 query rather than duplicating it. On create,
+      // the actor IS the new accessory's owner (this UI never collects an
+      // on-behalf `ownerId`), so the actor's own categories are the right set.
+      listOwnerAccessoryCategories(user.id),
+    ]);
+  // U9/R20: bounded (never per-item, KTD4) — marks rows with at least one due
+  // service rule of their own (never merely because a mounting firearm is
+  // due). Passes the already-fetched `firearms` through — `listFirearms`'s
+  // visible-firearm scope here matches this page's own fetch above, so
+  // `listDueForVisibleCollection` doesn't need to re-run it. (Deliberately
+  // NOT threading `accessories` — its scope there is owner-only, KTD3,
+  // narrower than this page's mount-inheriting `listAccessories`.)
+  const dueEntries = await listDueForVisibleCollection(
+    user.id,
+    undefined,
+    firearms,
+  );
+  const dueAccessoryIds = dueParentIds(dueEntries, "accessory");
 
-  // On create, the accessory's owner is the actor themself (KTD5's
-  // same-owner mount guard), so a firearm the actor merely has an edit GRANT
+  // On create, the accessory's owner is the actor themself (accessories-tracker
+  // plan KTD5's same-owner mount guard), so a firearm the actor merely has an edit GRANT
   // on — but doesn't own — would pass permission but fail
   // `authorizeCreateMount`'s cross-tenant check at submit; excluding it here
   // keeps the picker's options a strict subset of what will actually save.
@@ -53,6 +77,7 @@ export default async function AccessoriesPage({ searchParams }: PageProps) {
     notes: a.notes,
     isNfa: a.isNfa,
     currentFirearmId: a.currentFirearmId,
+    serviceDue: dueAccessoryIds.has(a.id),
   }));
 
   return (
@@ -63,6 +88,7 @@ export default async function AccessoriesPage({ searchParams }: PageProps) {
         editableFirearms={editableFirearms}
         firearmNames={firearmNames}
         initialMountFirearmId={initialMountFirearmId}
+        ownerCategories={ownerCategories}
       />
     </div>
   );
diff --git a/app/(app)/firearms/[id]/page.tsx b/app/(app)/firearms/[id]/page.tsx
index 744389a2..767af548 100644
--- a/app/(app)/firearms/[id]/page.tsx
+++ b/app/(app)/firearms/[id]/page.tsx
@@ -12,6 +12,11 @@ import {
   calibersForInput,
   manufacturers,
 } from "@/src/domain/reference/reference";
+import { withActorNames } from "@/src/domain/service-intervals/actor-names";
+import { getItemDueState } from "@/src/domain/service-intervals/due-service";
+import { listServiceHistory } from "@/src/domain/service-intervals/events-service";
+import { listItemRules } from "@/src/domain/service-intervals/rules-service";
+import { asNotFound } from "@/src/lib/as-not-found";
 import { isUuid } from "@/src/lib/uuid";
 import { FirearmDetailView } from "../firearm-detail-view";
 
@@ -50,6 +55,9 @@ export default async function FirearmDetailPage({ params }: PageProps) {
     mountedAccessories,
     photos,
     documents,
+    serviceRules,
+    itemRules,
+    history,
   ] = await Promise.all([
     calibersForInput(db, user.id),
     magazineCountForFirearm(user.id, id),
@@ -68,6 +76,12 @@ export default async function FirearmDetailPage({ params }: PageProps) {
           throw error;
         })
       : Promise.resolve([]),
+    // U8: the resolved, due-annotated rule set (any visibility level, R6).
+    getItemDueState(user.id, "firearm", id).catch(asNotFound),
+    // Raw item-rule rows — only their suppressed names are used here, to
+    // list what's hidden from `serviceRules` above (KTD6).
+    listItemRules(user.id, "firearm", id).catch(asNotFound),
+    listServiceHistory(user.id, "firearm", id).catch(asNotFound),
   ]);
 
   // Derive the value total from the already-fetched accessories rather than
@@ -81,6 +95,15 @@ export default async function FirearmDetailPage({ params }: PageProps) {
     ...new Set(firearms.map((f) => f.subtype).filter((s) => s.trim() !== "")),
   ].sort((a, b) => a.localeCompare(b));
 
+  const suppressedServiceRuleNames = itemRules
+    .filter((rule) => rule.suppressed)
+    .map((rule) => rule.name);
+
+  // Attach each history entry's actor display name (mirrors
+  // `inventory-log/log-actions.ts`'s `listLogAction` — resolves `name`, not
+  // `email`, since a view-grantee on a shared firearm can read this too).
+  const serviceHistory = await withActorNames(history);
+
   return (
     <FirearmDetailView
       firearm={{
@@ -95,6 +118,7 @@ export default async function FirearmDetailPage({ params }: PageProps) {
         serialNumber: row.serialNumber,
         notes: row.notes,
         isNfa: row.isNfa,
+        acquiredDate: row.acquiredDate ?? "",
       }}
       permission={permission}
       magazineCount={magazineCount}
@@ -110,6 +134,9 @@ export default async function FirearmDetailPage({ params }: PageProps) {
       // point: a bare `documents={documents}` would compile via structural
       // typing and leak the key.
       documents={documents.map(toFirearmDocumentRow)}
+      serviceRules={serviceRules}
+      suppressedServiceRuleNames={suppressedServiceRuleNames}
+      serviceHistory={serviceHistory}
     />
   );
 }
diff --git a/app/(app)/firearms/__tests__/service-actions.test.ts b/app/(app)/firearms/__tests__/service-actions.test.ts
new file mode 100644
index 00000000..01e2344e
--- /dev/null
+++ b/app/(app)/firearms/__tests__/service-actions.test.ts
@@ -0,0 +1,562 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+import { NotFoundError } from "@/src/auth/errors";
+import { ValidationError } from "@/src/domain/errors";
+import * as eventsService from "@/src/domain/service-intervals/events-service";
+import * as rulesService from "@/src/domain/service-intervals/rules-service";
+
+/**
+ * Server-action unit tests for `service-actions.ts` (U8) — auth gating,
+ * name-to-row resolution before a write, and `ActionResult` mapping.
+ *
+ * Uses `spyOn` on the real `rules-service`/`events-service` module
+ * namespaces (mutating the live export in place) rather than
+ * `mock.module(...)` on those two specifiers: `rules-service` is ALSO
+ * `mock.module`-replaced, with a completely different shape, by
+ * `settings/service/__tests__/actions.test.ts`. `mock.module` on a
+ * specifier both files import materializes the module once and locks in
+ * whichever mock resolved first for the rest of the `bun test` process
+ * (confirmed by direct repro) — a second, differently-shaped
+ * `mock.module` call on the same path from this file broke the OTHER
+ * file's tests outright. `spyOn` sidesteps this: it overrides the named
+ * export on the already-loaded module object directly, with no shared
+ * "first-to-resolve-a-mocked-specifier-wins" registry involved, so the two
+ * test files stop colliding.
+ */
+
+let currentUserId: string | null = null;
+mock.module("@/src/auth/session", () => ({
+  getCurrentUser: async () => (currentUserId ? { id: currentUserId } : null),
+}));
+
+let revalidateCalls: string[] = [];
+mock.module("next/cache", () => ({
+  revalidatePath: (path: string) => {
+    revalidateCalls.push(path);
+  },
+}));
+
+const {
+  logServiceEventAction,
+  updateServiceEventAction,
+  deleteServiceEventAction,
+  overrideServiceRuleAction,
+  addItemOnlyRuleAction,
+  resetServiceRuleAction,
+  suppressServiceRuleAction,
+  restoreServiceRuleAction,
+  removeItemOnlyRuleAction,
+} = await import("../service-actions");
+
+type ServiceRuleRowLike = rulesService.ServiceRuleRow;
+
+function ruleRow(id: string, name: string): ServiceRuleRowLike {
+  return { id, name, suppressed: false } as ServiceRuleRowLike;
+}
+
+describe("service-actions (U8)", () => {
+  let listItemRulesSpy: ReturnType<typeof spyOn>;
+  let createItemRuleSpy: ReturnType<typeof spyOn>;
+  let updateItemRuleSpy: ReturnType<typeof spyOn>;
+  let deleteItemRuleSpy: ReturnType<typeof spyOn>;
+  let logServiceEventSpy: ReturnType<typeof spyOn>;
+  let updateServiceEventSpy: ReturnType<typeof spyOn>;
+  let deleteServiceEventSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    currentUserId = null;
+    revalidateCalls = [];
+    listItemRulesSpy = spyOn(rulesService, "listItemRules").mockResolvedValue(
+      [],
+    );
+    createItemRuleSpy = spyOn(rulesService, "createItemRule").mockResolvedValue(
+      ruleRow("new-rule", "unused"),
+    );
+    updateItemRuleSpy = spyOn(rulesService, "updateItemRule").mockResolvedValue(
+      ruleRow("updated-rule", "unused"),
+    );
+    deleteItemRuleSpy = spyOn(rulesService, "deleteItemRule").mockResolvedValue(
+      undefined,
+    );
+    logServiceEventSpy = spyOn(
+      eventsService,
+      "logServiceEvent",
+    ).mockResolvedValue({ id: "event-1", ruleName: "Cleaning" } as never);
+    updateServiceEventSpy = spyOn(
+      eventsService,
+      "updateServiceEvent",
+    ).mockResolvedValue({
+      id: "event-1",
+      ruleName: "Cleaning",
+      firearmId: "fa-1",
+      accessoryId: null,
+    } as never);
+    deleteServiceEventSpy = spyOn(
+      eventsService,
+      "deleteServiceEvent",
+    ).mockResolvedValue({
+      id: "event-1",
+      ruleName: "Cleaning",
+      firearmId: "fa-1",
+      accessoryId: null,
+    } as never);
+  });
+
+  afterEach(() => {
+    listItemRulesSpy.mockRestore();
+    createItemRuleSpy.mockRestore();
+    updateItemRuleSpy.mockRestore();
+    deleteItemRuleSpy.mockRestore();
+    logServiceEventSpy.mockRestore();
+    updateServiceEventSpy.mockRestore();
+    deleteServiceEventSpy.mockRestore();
+  });
+
+  describe("logServiceEventAction", () => {
+    test("rejects an unauthenticated caller without touching the service", async () => {
+      currentUserId = null;
+
+      const result = await logServiceEventAction("firearm", "fa-1", {
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+      });
+
+      expect(result.ok).toBe(false);
+      expect(logServiceEventSpy).not.toHaveBeenCalled();
+    });
+
+    test("forwards the resolved actor id and input, and revalidates the firearm's path", async () => {
+      currentUserId = "user-1";
+
+      const result = await logServiceEventAction("firearm", "fa-1", {
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+        notes: "Field strip",
+      });
+
+      expect(result.ok).toBe(true);
+      expect(logServiceEventSpy).toHaveBeenCalledWith(
+        "user-1",
+        "firearm",
+        "fa-1",
+        {
+          ruleName: "Cleaning",
+          servicedOn: "2026-01-01",
+          notes: "Field strip",
+        },
+      );
+      expect(revalidateCalls).toContain("/firearms/fa-1");
+    });
+
+    test("revalidates the accessory's path for an accessory parent", async () => {
+      currentUserId = "user-1";
+
+      await logServiceEventAction("accessory", "acc-1", {
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+      });
+
+      expect(revalidateCalls).toContain("/accessories/acc-1");
+    });
+
+    test("maps a thrown ValidationError to a failed ActionResult with codes", async () => {
+      currentUserId = "user-1";
+      logServiceEventSpy.mockImplementation(() => {
+        throw new ValidationError(["servicedOnInFuture"]);
+      });
+
+      const result = await logServiceEventAction("firearm", "fa-1", {
+        ruleName: "Cleaning",
+        servicedOn: "2099-01-01",
+      });
+
+      expect(result.ok).toBe(false);
+      expect(result.ok === false && result.codes).toEqual([
+        "servicedOnInFuture",
+      ]);
+    });
+  });
+
+  describe("overrideServiceRuleAction", () => {
+    test("creates a new item rule when the item has no entry for that name yet", async () => {
+      currentUserId = "user-1";
+      listItemRulesSpy.mockResolvedValue([]);
+
+      const result = await overrideServiceRuleAction("firearm", "fa-1", {
+        name: "Barrel",
+        intervalDays: null,
+        intervalSessions: null,
+        intervalRounds: 4000,
+      });
+
+      expect(result.ok).toBe(true);
+      expect(createItemRuleSpy).toHaveBeenCalledWith(
+        "user-1",
+        "firearm",
+        "fa-1",
+        {
+          name: "Barrel",
+          intervalDays: null,
+          intervalSessions: null,
+          intervalRounds: 4000,
+          suppressed: false,
+        },
+        // The empty sibling list `findItemRuleByName`'s `listItemRules` call
+        // already resolved, threaded through so the write skips reloading it.
+        [],
+      );
+      expect(updateItemRuleSpy).not.toHaveBeenCalled();
+      expect(revalidateCalls).toContain("/firearms/fa-1");
+    });
+
+    test("updates the existing item rule by id when one already exists for that name", async () => {
+      currentUserId = "user-1";
+      const siblings = [ruleRow("rule-42", "Barrel")];
+      listItemRulesSpy.mockResolvedValue(siblings);
+
+      const result = await overrideServiceRuleAction("firearm", "fa-1", {
+        name: "Barrel",
+        intervalDays: null,
+        intervalSessions: null,
+        intervalRounds: 3000,
+      });
+
+      expect(result.ok).toBe(true);
+      expect(updateItemRuleSpy).toHaveBeenCalledWith(
+        "user-1",
+        "firearm",
+        "fa-1",
+        "rule-42",
+        {
+          name: "Barrel",
+          intervalDays: null,
+          intervalSessions: null,
+          intervalRounds: 3000,
+          suppressed: false,
+        },
+        // The sibling list (including the row itself) already resolved by
+        // `findItemRuleByName`, threaded through to skip a reload.
+        siblings,
+      );
+      expect(createItemRuleSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("addItemOnlyRuleAction", () => {
+    test("creates an unsuppressed rule and revalidates", async () => {
+      currentUserId = "user-1";
+
+      const result = await addItemOnlyRuleAction("accessory", "acc-1", {
+        name: "Lens cleaning",
+        intervalDays: 90,
+        intervalSessions: null,
+        intervalRounds: null,
+      });
+
+      expect(result.ok).toBe(true);
+      expect(createItemRuleSpy).toHaveBeenCalledWith(
+        "user-1",
+        "accessory",
+        "acc-1",
+        {
+          name: "Lens cleaning",
+          intervalDays: 90,
+          intervalSessions: null,
+          intervalRounds: null,
+          suppressed: false,
+        },
+      );
+      expect(revalidateCalls).toContain("/accessories/acc-1");
+    });
+  });
+
+  describe("resetServiceRuleAction", () => {
+    test("deletes the existing item rule by its resolved id", async () => {
+      currentUserId = "user-1";
+      listItemRulesSpy.mockResolvedValue([ruleRow("rule-7", "Barrel")]);
+
+      const result = await resetServiceRuleAction("firearm", "fa-1", "Barrel");
+
+      expect(result.ok).toBe(true);
+      expect(deleteItemRuleSpy).toHaveBeenCalledWith(
+        "user-1",
+        "firearm",
+        "fa-1",
+        "rule-7",
+      );
+    });
+
+    test("returns a non-leaking error and deletes nothing when no override exists for that name", async () => {
+      currentUserId = "user-1";
+      listItemRulesSpy.mockResolvedValue([]);
+
+      const result = await resetServiceRuleAction("firearm", "fa-1", "Barrel");
+
+      expect(result.ok).toBe(false);
+      expect(deleteItemRuleSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("suppressServiceRuleAction", () => {
+    test("updates the existing row to suppressed when one exists", async () => {
+      currentUserId = "user-1";
+      const siblings = [ruleRow("rule-9", "Cleaning")];
+      listItemRulesSpy.mockResolvedValue(siblings);
+
+      const result = await suppressServiceRuleAction(
+        "firearm",
+        "fa-1",
+        "Cleaning",
+      );
+
+      expect(result.ok).toBe(true);
+      expect(updateItemRuleSpy).toHaveBeenCalledWith(
+        "user-1",
+        "firearm",
+        "fa-1",
+        "rule-9",
+        { name: "Cleaning", suppressed: true },
+        // Already-resolved siblings threaded through to skip a reload.
+        siblings,
+      );
+      expect(createItemRuleSpy).not.toHaveBeenCalled();
+    });
+
+    test("creates a new suppressed row when the item has no entry yet (suppressing an inherited default)", async () => {
+      currentUserId = "user-1";
+      listItemRulesSpy.mockResolvedValue([]);
+
+      const result = await suppressServiceRuleAction(
+        "firearm",
+        "fa-1",
+        "Cleaning",
+      );
+
+      expect(result.ok).toBe(true);
+      expect(createItemRuleSpy).toHaveBeenCalledWith(
+        "user-1",
+        "firearm",
+        "fa-1",
+        { name: "Cleaning", suppressed: true },
+        // Already-resolved (empty) siblings threaded through to skip a reload.
+        [],
+      );
+      expect(updateItemRuleSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("restoreServiceRuleAction", () => {
+    test("deletes the suppressed row by its resolved id", async () => {
+      currentUserId = "user-1";
+      listItemRulesSpy.mockResolvedValue([ruleRow("rule-3", "Cleaning")]);
+
+      const result = await restoreServiceRuleAction(
+        "firearm",
+        "fa-1",
+        "Cleaning",
+      );
+
+      expect(result.ok).toBe(true);
+      expect(deleteItemRuleSpy).toHaveBeenCalledWith(
+        "user-1",
+        "firearm",
+        "fa-1",
+        "rule-3",
+      );
+    });
+
+    test("returns a non-leaking error when nothing is suppressed under that name", async () => {
+      currentUserId = "user-1";
+      listItemRulesSpy.mockResolvedValue([]);
+
+      const result = await restoreServiceRuleAction(
+        "firearm",
+        "fa-1",
+        "Cleaning",
+      );
+
+      expect(result.ok).toBe(false);
+      expect(deleteItemRuleSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("removeItemOnlyRuleAction (item-only rules get Remove, not Suppress)", () => {
+    test("deletes the existing item-only rule by its resolved id", async () => {
+      currentUserId = "user-1";
+      listItemRulesSpy.mockResolvedValue([ruleRow("rule-11", "Lens cleaning")]);
+
+      const result = await removeItemOnlyRuleAction(
+        "accessory",
+        "acc-1",
+        "Lens cleaning",
+      );
+
+      expect(result.ok).toBe(true);
+      expect(deleteItemRuleSpy).toHaveBeenCalledWith(
+        "user-1",
+        "accessory",
+        "acc-1",
+        "rule-11",
+      );
+      expect(revalidateCalls).toContain("/accessories/acc-1");
+      // The delete is the same write `resetServiceRuleAction` performs, but
+      // `updateItemRule` (suppress's nulling-of-thresholds write) is never
+      // touched — this is a deletion, not a suppression.
+      expect(updateItemRuleSpy).not.toHaveBeenCalled();
+    });
+
+    test("returns a non-leaking error and deletes nothing when no rule exists under that name", async () => {
+      currentUserId = "user-1";
+      listItemRulesSpy.mockResolvedValue([]);
+
+      const result = await removeItemOnlyRuleAction(
+        "firearm",
+        "fa-1",
+        "Recoil spring",
+      );
+
+      expect(result.ok).toBe(false);
+      expect(deleteItemRuleSpy).not.toHaveBeenCalled();
+    });
+
+    test("rejects an unauthenticated caller without touching the service", async () => {
+      currentUserId = null;
+      listItemRulesSpy.mockResolvedValue([ruleRow("rule-11", "Lens cleaning")]);
+
+      const result = await removeItemOnlyRuleAction(
+        "accessory",
+        "acc-1",
+        "Lens cleaning",
+      );
+
+      expect(result.ok).toBe(false);
+      expect(deleteItemRuleSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  // ---- correction path: updateServiceEventAction / deleteServiceEventAction ----
+
+  describe("updateServiceEventAction", () => {
+    test("rejects an unauthenticated caller without touching the service", async () => {
+      currentUserId = null;
+
+      const result = await updateServiceEventAction("event-1", {
+        servicedOn: "2026-01-02",
+      });
+
+      expect(result.ok).toBe(false);
+      expect(updateServiceEventSpy).not.toHaveBeenCalled();
+    });
+
+    test("forwards the resolved actor id, eventId, and input — never a parentType/parentId the client supplied", async () => {
+      currentUserId = "user-1";
+
+      const result = await updateServiceEventAction("event-1", {
+        servicedOn: "2026-01-02",
+        notes: "corrected",
+      });
+
+      expect(result.ok).toBe(true);
+      expect(updateServiceEventSpy).toHaveBeenCalledWith("user-1", "event-1", {
+        servicedOn: "2026-01-02",
+        notes: "corrected",
+      });
+    });
+
+    test("revalidates the firearm's path using the returned row's own parent", async () => {
+      currentUserId = "user-1";
+      updateServiceEventSpy.mockResolvedValue({
+        id: "event-1",
+        ruleName: "Cleaning",
+        firearmId: "fa-1",
+        accessoryId: null,
+      } as never);
+
+      await updateServiceEventAction("event-1", { servicedOn: "2026-01-02" });
+
+      expect(revalidateCalls).toContain("/firearms/fa-1");
+    });
+
+    test("revalidates the accessory's path using the returned row's own parent", async () => {
+      currentUserId = "user-1";
+      updateServiceEventSpy.mockResolvedValue({
+        id: "event-2",
+        ruleName: "Cleaning",
+        firearmId: null,
+        accessoryId: "acc-1",
+      } as never);
+
+      await updateServiceEventAction("event-2", { servicedOn: "2026-01-02" });
+
+      expect(revalidateCalls).toContain("/accessories/acc-1");
+    });
+
+    test("maps a thrown ValidationError to a failed ActionResult with codes", async () => {
+      currentUserId = "user-1";
+      updateServiceEventSpy.mockImplementation(() => {
+        throw new ValidationError(["servicedOnInFuture"]);
+      });
+
+      const result = await updateServiceEventAction("event-1", {
+        servicedOn: "2099-01-01",
+      });
+
+      expect(result.ok).toBe(false);
+      expect(result.ok === false && result.codes).toEqual([
+        "servicedOnInFuture",
+      ]);
+    });
+  });
+
+  describe("deleteServiceEventAction", () => {
+    test("rejects an unauthenticated caller without touching the service", async () => {
+      currentUserId = null;
+
+      const result = await deleteServiceEventAction("event-1");
+
+      expect(result.ok).toBe(false);
+      expect(deleteServiceEventSpy).not.toHaveBeenCalled();
+    });
+
+    test("forwards the resolved actor id and eventId only", async () => {
+      currentUserId = "user-1";
+
+      const result = await deleteServiceEventAction("event-1");
+
+      expect(result.ok).toBe(true);
+      expect(deleteServiceEventSpy).toHaveBeenCalledWith("user-1", "event-1");
+    });
+
+    test("revalidates the accessory's path using the deleted row's own parent", async () => {
+      currentUserId = "user-1";
+      deleteServiceEventSpy.mockResolvedValue({
+        id: "event-3",
+        ruleName: "Cleaning",
+        firearmId: null,
+        accessoryId: "acc-9",
+      } as never);
+
+      await deleteServiceEventAction("event-3");
+
+      expect(revalidateCalls).toContain("/accessories/acc-9");
+    });
+
+    test("returns a non-leaking error when the event is not found", async () => {
+      currentUserId = "user-1";
+      deleteServiceEventSpy.mockImplementation(() => {
+        throw new NotFoundError();
+      });
+
+      const result = await deleteServiceEventAction("missing-event");
+
+      expect(result.ok).toBe(false);
+    });
+  });
+});
diff --git a/app/(app)/firearms/firearm-detail-view.tsx b/app/(app)/firearms/firearm-detail-view.tsx
index 033f1783..3bfc438d 100644
--- a/app/(app)/firearms/firearm-detail-view.tsx
+++ b/app/(app)/firearms/firearm-detail-view.tsx
@@ -18,6 +18,7 @@ import {
   firearmTypeLabel,
 } from "@/src/domain/firearms/constants";
 import { firearmDisplayName, hasNickname } from "@/src/domain/firearms/display";
+import type { RuleDueState } from "@/src/domain/service-intervals/due-service";
 import { InventoryLogHistory } from "../inventory-log/inventory-log-history";
 import { FirearmDocuments } from "./[id]/firearm-documents";
 import { type FirearmPhotoRow, FirearmPhotos } from "./[id]/firearm-photos";
@@ -28,6 +29,8 @@ import {
   type MountedAccessoryRow,
 } from "./mounted-accessories";
 import { RangeSessionHistory } from "./range-session-history";
+import { ServiceHistory, type ServiceHistoryEntry } from "./service-history";
+import { ServiceRulesPanel } from "./service-rules-panel";
 
 export interface FirearmDetail extends FirearmFormValues {
   id: string;
@@ -48,6 +51,12 @@ interface FirearmDetailViewProps {
   /** Server-loaded via `listDocuments` for the OWNER only (empty for a
    * non-owner, who never sees the section this feeds — U7, R16). */
   documents: FirearmDocumentRow[];
+  /** Resolved, due-annotated rule set (U8, U4's `getItemDueState`). */
+  serviceRules: RuleDueState[];
+  /** Names of this firearm's suppressed rules (U8, KTD6). */
+  suppressedServiceRuleNames: string[];
+  /** Service history, newest first (U8, R17). */
+  serviceHistory: ServiceHistoryEntry[];
 }
 
 export function FirearmDetailView({
@@ -61,6 +70,9 @@ export function FirearmDetailView({
   accessoryValueCents,
   photos,
   documents,
+  serviceRules,
+  suppressedServiceRuleNames,
+  serviceHistory,
 }: FirearmDetailViewProps) {
   const router = useRouter();
   const [editing, setEditing] = useState(false);
@@ -168,6 +180,10 @@ export function FirearmDetailView({
               value={firearmActionLabel(firearm.action)}
             />
             <DetailRow label="Subtype" value={orDash(firearm.subtype)} />
+            <DetailRow
+              label="Acquired date"
+              value={orDash(firearm.acquiredDate)}
+            />
             <DetailRow
               label="Serial number"
               value={
@@ -240,6 +256,22 @@ export function FirearmDetailView({
         onChange={() => router.refresh()}
       />
 
+      <ServiceRulesPanel
+        parentType="firearm"
+        parentId={firearm.id}
+        rules={serviceRules}
+        suppressedRuleNames={suppressedServiceRuleNames}
+        canManageRules={isOwner}
+        canLogService={canEdit}
+        onChange={() => router.refresh()}
+      />
+
+      <ServiceHistory
+        entries={serviceHistory}
+        canWrite={canEdit}
+        onChange={() => router.refresh()}
+      />
+
       <InventoryLogHistory
         parentType="firearm"
         parentId={firearm.id}
diff --git a/app/(app)/firearms/firearm-form.tsx b/app/(app)/firearms/firearm-form.tsx
index 423cdfdb..ea17cb1d 100644
--- a/app/(app)/firearms/firearm-form.tsx
+++ b/app/(app)/firearms/firearm-form.tsx
@@ -34,6 +34,8 @@ export interface FirearmFormValues {
   serialNumber: string;
   notes: string;
   isNfa: boolean;
+  /** ISO date, or `""` when unset — mirrors magazine/ammo's acquired date. */
+  acquiredDate: string;
 }
 
 interface FirearmFormProps {
@@ -57,6 +59,7 @@ const EMPTY: FirearmFormValues = {
   serialNumber: "",
   notes: "",
   isNfa: false,
+  acquiredDate: "",
 };
 
 const TYPE_CODES: FirearmValidationCode[] = ["invalidType", "typeRequired"];
@@ -64,6 +67,10 @@ const ACTION_CODES: FirearmValidationCode[] = [
   "invalidAction",
   "actionRequired",
 ];
+const ACQUIRED_DATE_CODES: FirearmValidationCode[] = [
+  "invalidAcquiredDate",
+  "acquiredDateInFuture",
+];
 
 interface ClassificationSelectProps {
   id: string;
@@ -139,6 +146,7 @@ export function FirearmForm({
   const subtypeId = useId();
   const notesId = useId();
   const serialId = useId();
+  const dateId = useId();
 
   function set<K extends keyof FirearmFormValues>(key: K, value: string) {
     setValues((v) => ({ ...v, [key]: value }));
@@ -151,11 +159,16 @@ export function FirearmForm({
     { codes: ["emptyCaliber"], id: calId },
     { codes: TYPE_CODES, id: typeId },
     { codes: ACTION_CODES, id: actionId },
+    { codes: ACQUIRED_DATE_CODES, id: dateId },
   ];
 
   function submit(event: React.FormEvent<HTMLFormElement>) {
     event.preventDefault();
-    const found = validateFirearm(values);
+    // Empty means unset (null), not "" — mirrors the magazine/accessory
+    // acquired/installed-date fields, so a cleared field persists as null
+    // rather than failing validation on an empty string.
+    const input = { ...values, acquiredDate: values.acquiredDate || null };
+    const found = validateFirearm(input);
     setCodes(found);
     setServerError(null);
     if (found.length > 0) {
@@ -168,8 +181,8 @@ export function FirearmForm({
     startTransition(async () => {
       const result =
         isEdit && initial?.id
-          ? await updateFirearmAction(initial.id, values)
-          : await createFirearmAction(values);
+          ? await updateFirearmAction(initial.id, input)
+          : await createFirearmAction(input);
       if (result.ok) {
         toast({
           message: isEdit ? "Changes saved" : "Firearm logged",
@@ -298,13 +311,29 @@ export function FirearmForm({
           onChange={(e) => set("serialNumber", e.target.value)}
         />
       </Field>
-      <Field label="Notes" controlId={notesId}>
-        <Textarea
-          id={notesId}
-          value={values.notes}
-          onChange={(e) => set("notes", e.target.value)}
-        />
-      </Field>
+      <div className="grid gap-4 sm:grid-cols-2">
+        <Field
+          label="Acquired date"
+          controlId={dateId}
+          hint="Optional"
+          error={firstMessage(codes, ACQUIRED_DATE_CODES)}
+        >
+          <Input
+            id={dateId}
+            type="date"
+            value={values.acquiredDate}
+            onChange={(e) => set("acquiredDate", e.target.value)}
+            aria-invalid={ACQUIRED_DATE_CODES.some((c) => codes.includes(c))}
+          />
+        </Field>
+        <Field label="Notes" controlId={notesId}>
+          <Textarea
+            id={notesId}
+            value={values.notes}
+            onChange={(e) => set("notes", e.target.value)}
+          />
+        </Field>
+      </div>
       <label className="flex cursor-pointer items-center gap-3">
         <input
           type="checkbox"
diff --git a/app/(app)/firearms/firearms-view.tsx b/app/(app)/firearms/firearms-view.tsx
index 2c01f42a..2a53f81a 100644
--- a/app/(app)/firearms/firearms-view.tsx
+++ b/app/(app)/firearms/firearms-view.tsx
@@ -24,7 +24,7 @@ import {
   createDefaultTableViewState,
   type TableViewState,
 } from "@/components/ui/data-table/types";
-import { EmptyState } from "@/components/ui/feedback";
+import { Badge, EmptyState } from "@/components/ui/feedback";
 import {
   PhotoThumbnail,
   type ThumbnailPhoto,
@@ -57,6 +57,13 @@ export interface FirearmListItem extends FirearmFormValues {
   /** This firearm's primary photo, batch-resolved by the page loader via
    * `primaryThumbnailsFor` (R18) — `null` when it has none (R22). */
   primaryPhoto: ThumbnailPhoto | null;
+  /**
+   * True when this firearm itself has at least one due service rule (U9,
+   * R20) — never true merely because an accessory mounted to it is due; that
+   * marks the accessory's own row instead. Advisory only (R21): a marker, not
+   * a gate.
+   */
+  serviceDue: boolean;
 }
 
 interface FirearmsViewProps {
@@ -165,6 +172,16 @@ export function FirearmsView({
           </>
         ),
       },
+      {
+        id: "serviceDue",
+        header: "Service",
+        meta: { label: "Service" },
+        enableSorting: false,
+        cell: ({ row }) =>
+          row.original.serviceDue ? (
+            <Badge tone="destructive">Service due</Badge>
+          ) : null,
+      },
       {
         accessorKey: "caliber",
         id: "caliber",
diff --git a/app/(app)/firearms/log-service-form.tsx b/app/(app)/firearms/log-service-form.tsx
new file mode 100644
index 00000000..1157e3d0
--- /dev/null
+++ b/app/(app)/firearms/log-service-form.tsx
@@ -0,0 +1,129 @@
+"use client";
+
+import { type FormEvent, useId, useState, useTransition } from "react";
+import { Button } from "@/components/ui/button";
+import { Callout } from "@/components/ui/feedback";
+import { Field } from "@/components/ui/field";
+import { Input, Textarea } from "@/components/ui/input";
+import type { ActionResult } from "@/src/domain/action-result";
+import type { ServiceEventRow } from "@/src/domain/service-intervals/events-service";
+import {
+  type ServiceEventInput,
+  validateServiceEventInput,
+} from "@/src/domain/service-intervals/validate-event";
+import { firstMessage, messageForCode } from "@/src/domain/validation-messages";
+import { todayIso } from "@/src/lib/dates";
+
+/**
+ * The log-service action form (U8, R14) — one rule, a date, and optional
+ * notes. `ruleName` is fixed by which rule's "Log service" button opened
+ * this form (not a user-facing field), matching F2's per-rule logging flow.
+ * Validated client-side with the SAME `validateServiceEventInput` the
+ * server enforces (`events-service.ts`), including the future-date rejection
+ * (`servicedOnInFuture`) — a service event records something that already
+ * happened.
+ */
+
+const DATE_CODES = [
+  "emptyServicedOn",
+  "invalidServicedOn",
+  "servicedOnInFuture",
+];
+
+export interface LogServiceFormProps {
+  ruleName: string;
+  onSubmit: (
+    input: ServiceEventInput,
+  ) => Promise<ActionResult<{ event: ServiceEventRow }>>;
+  onCancel: () => void;
+  onSaved: () => void;
+}
+
+export function LogServiceForm({
+  ruleName,
+  onSubmit,
+  onCancel,
+  onSaved,
+}: LogServiceFormProps) {
+  const [servicedOn, setServicedOn] = useState(todayIso());
+  const [notes, setNotes] = useState("");
+  const [codes, setCodes] = useState<string[]>([]);
+  const [serverError, setServerError] = useState<string | null>(null);
+  const [pending, startTransition] = useTransition();
+  const dateId = useId();
+  const notesId = useId();
+
+  function submit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    const input: ServiceEventInput = { ruleName, servicedOn, notes };
+    const found = validateServiceEventInput(input);
+    setCodes(found);
+    setServerError(null);
+    if (found.length > 0) {
+      document.getElementById(dateId)?.focus();
+      return;
+    }
+    startTransition(async () => {
+      const result = await onSubmit(input);
+      if (result.ok) {
+        onSaved();
+      } else if (result.codes) {
+        setCodes(result.codes);
+        const nonDateCode = result.codes.find(
+          (code) => !DATE_CODES.includes(code),
+        );
+        if (nonDateCode) {
+          setServerError(messageForCode(nonDateCode));
+        }
+      } else {
+        setServerError(result.error ?? "Could not log service.");
+      }
+    });
+  }
+
+  return (
+    <form
+      onSubmit={submit}
+      aria-label={`Log service — ${ruleName}`}
+      className="flex flex-col gap-3 rounded-md border border-input p-3"
+      noValidate
+    >
+      {serverError ? <Callout tone="destructive">{serverError}</Callout> : null}
+      <Field
+        label="Date serviced"
+        controlId={dateId}
+        required
+        error={firstMessage(codes, DATE_CODES)}
+      >
+        <Input
+          id={dateId}
+          type="date"
+          value={servicedOn}
+          onChange={(e) => setServicedOn(e.target.value)}
+          aria-invalid={DATE_CODES.some((c) => codes.includes(c))}
+        />
+      </Field>
+      <Field label="Notes" controlId={notesId}>
+        <Textarea
+          id={notesId}
+          value={notes}
+          onChange={(e) => setNotes(e.target.value)}
+        />
+      </Field>
+      <div className="flex items-center gap-2">
+        <Button type="submit" size="sm" disabled={pending}>
+          {pending ? "Logging…" : "Log service"}
+        </Button>
+        <Button
+          type="button"
+          variant="ghost"
+          size="sm"
+          onClick={onCancel}
+          disabled={pending}
+        >
+          Cancel
+        </Button>
+      </div>
+    </form>
+  );
+}
diff --git a/app/(app)/firearms/page.tsx b/app/(app)/firearms/page.tsx
index 33e3cc4c..4bc5b3d4 100644
--- a/app/(app)/firearms/page.tsx
+++ b/app/(app)/firearms/page.tsx
@@ -9,6 +9,10 @@ import {
   calibersForInput,
   manufacturers,
 } from "@/src/domain/reference/reference";
+import {
+  dueParentIds,
+  listDueForVisibleCollection,
+} from "@/src/domain/service-intervals/due-service";
 import { inventorySummary } from "@/src/domain/summary/summary";
 import { type FirearmListItem, FirearmsView } from "./firearms-view";
 
@@ -18,11 +22,23 @@ export default async function FirearmsPage() {
 
   // Needs the visible firearm id set, so it can't join the Promise.all below —
   // still a single batched query (R18), just sequenced after the list fetch
-  // rather than run per row.
+  // rather than run per row. Reused below (rather than re-fetched) by both
+  // `listDueForVisibleCollection` and `inventorySummary`, which would
+  // otherwise each re-run `listFirearms`'s own two round trips.
   const firearms = await listFirearms(user.id);
+  // U9/R20: fetched once, bounded (never per-item, KTD4), and reused for both
+  // `summary`'s roll-up counts and marking rows with at least one due service
+  // rule — `inventorySummary` would otherwise re-run this same batched
+  // pipeline (defaults + item rules + last-service-points + session rows)
+  // internally.
+  const dueEntries = await listDueForVisibleCollection(
+    user.id,
+    undefined,
+    firearms,
+  );
   const [summary, caliberSuggestions, permissions, primaryThumbnails] =
     await Promise.all([
-      inventorySummary(user.id),
+      inventorySummary(user.id, dueEntries, firearms),
       calibersForInput(db, user.id),
       visibleFirearmPermissions(db, user.id),
       primaryThumbnailsFor(
@@ -30,6 +46,7 @@ export default async function FirearmsPage() {
         firearms.map((f) => f.id),
       ),
     ]);
+  const dueFirearmIds = dueParentIds(dueEntries, "firearm");
   // Reuse the permission map's keys (the visible firearm set) so the round-total
   // aggregation doesn't re-derive owned∪granted a second time.
   const roundTotals = await lifetimeRoundTotals(
@@ -59,9 +76,11 @@ export default async function FirearmsPage() {
     serialNumber: f.serialNumber,
     notes: f.notes,
     isNfa: f.isNfa,
+    acquiredDate: f.acquiredDate ?? "",
     magazineCount: counts.get(f.id) ?? 0,
     roundTotal: roundTotals.get(f.id) ?? 0,
     primaryPhoto: primaryThumbnails.get(f.id) ?? null,
+    serviceDue: dueFirearmIds.has(f.id),
   }));
   // Serial column shows only when at least one visible firearm has a serial (R71).
   const showSerial = firearms.some((f) => f.serialNumber.trim() !== "");
diff --git a/app/(app)/firearms/range-session-form.tsx b/app/(app)/firearms/range-session-form.tsx
index 094e522e..fba92781 100644
--- a/app/(app)/firearms/range-session-form.tsx
+++ b/app/(app)/firearms/range-session-form.tsx
@@ -8,6 +8,7 @@ import { Input, Textarea } from "@/components/ui/input";
 import { useToast } from "@/components/ui/toast";
 import { validateRangeSession } from "@/src/domain/range-sessions/validate";
 import { firstMessage } from "@/src/domain/validation-messages";
+import { todayIso } from "@/src/lib/dates";
 import {
   logRangeSessionAction,
   updateRangeSessionAction,
@@ -24,13 +25,6 @@ export interface RangeSessionFormValues {
 const DATE_CODES = ["emptyDate", "invalidDate"];
 const ROUNDS_CODES = ["invalidRoundsFired"];
 
-/** Today's calendar date (KTD5 default), local time. */
-function todayIso(): string {
-  const now = new Date();
-  const offsetMs = now.getTimezoneOffset() * 60_000;
-  return new Date(now.getTime() - offsetMs).toISOString().slice(0, 10);
-}
-
 interface RangeSessionFormProps {
   firearmId: string;
   initial?: RangeSessionFormValues;
diff --git a/app/(app)/firearms/service-actions.ts b/app/(app)/firearms/service-actions.ts
new file mode 100644
index 00000000..3fb520a0
--- /dev/null
+++ b/app/(app)/firearms/service-actions.ts
@@ -0,0 +1,309 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { NotFoundError } from "@/src/auth/errors";
+import type { ActionResult } from "@/src/domain/action-result";
+import {
+  deleteServiceEvent,
+  logServiceEvent,
+  resolveServiceEventParent,
+  type ServiceEventInput,
+  type ServiceEventRow,
+  type ServiceEventUpdateInput,
+  updateServiceEvent,
+} from "@/src/domain/service-intervals/events-service";
+import {
+  createItemRule,
+  deleteItemRule,
+  type ItemRuleInput,
+  listItemRules,
+  type ServiceParentType,
+  type ServiceRuleRow,
+  updateItemRule,
+} from "@/src/domain/service-intervals/rules-service";
+import type { ServiceRuleInput } from "@/src/domain/service-intervals/validate";
+import { withActionContext } from "@/src/lib/logging/entry-context";
+
+/**
+ * Server actions for the item-detail service panel (U8) — log-service and
+ * the five rule actions (override, reset-to-inherited, suppress, restore,
+ * add-item-only) — plus, for the service-history list, the correction path's
+ * two actions: `updateServiceEventAction` ("Save changes") and
+ * `deleteServiceEventAction` ("Delete"). Shared by both families:
+ * `service-rules-panel.tsx` and `service-history.tsx` are the one panel/
+ * history component for firearms and accessories alike, and both import this
+ * single module regardless of which detail view mounts them (mirroring
+ * `mounted-accessories.tsx` already living in `firearms/` and being
+ * referenced from the accessories side) — `accessories/actions.ts` gains no
+ * parallel copy of these, since every domain call here is already generic
+ * over `ServiceParentType` and a second wrapper module would just be
+ * duplication with nothing accessory-specific to add (KISS/DRY).
+ *
+ * Every write here delegates authorization entirely to `rules-service.ts` /
+ * `events-service.ts` (KTD3) — this file never re-implements a permission
+ * check. The rule actions are keyed by rule NAME from the client's point of
+ * view (the resolved-rule shape `getItemDueState` already returns has no
+ * item-rule row id for an "inherited" rule, since none exists yet) — each
+ * action here resolves the name to an existing item-rule row, if one
+ * exists, immediately before the authorized write.
+ */
+
+function revalidateItemPath(
+  parentType: ServiceParentType,
+  parentId: string,
+): void {
+  revalidatePath(
+    parentType === "firearm"
+      ? `/firearms/${parentId}`
+      : `/accessories/${parentId}`,
+  );
+}
+
+/**
+ * Resolves which existing item-rule row (if any) `name` refers to, alongside
+ * the FULL sibling list `listItemRules` already loaded to find it —
+ * returned so a caller proceeding to `createItemRule`/`updateItemRule` can
+ * pass `siblings` through as `preloadedSiblings` and skip having that same
+ * item's rules reloaded a second time purely for the duplicate-name check
+ * those functions would otherwise re-run themselves. This does NOT replace
+ * either function's own authorization check — `listItemRules` here resolves
+ * READ visibility (any of owner/edit/view for a firearm, KTD3), while
+ * `createItemRule`/`updateItemRule` separately and unconditionally enforce
+ * the stricter WRITE gate (owner-only for a firearm) inside their own
+ * transaction — so this helper only ever narrows what has to be reloaded,
+ * never what has to be re-authorized.
+ */
+async function findItemRuleByName(
+  userId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+  name: string,
+): Promise<{ existing: ServiceRuleRow | null; siblings: ServiceRuleRow[] }> {
+  const rows = await listItemRules(userId, parentType, parentId);
+  return {
+    existing: rows.find((row) => row.name === name) ?? null,
+    siblings: rows,
+  };
+}
+
+export async function logServiceEventAction(
+  parentType: ServiceParentType,
+  parentId: string,
+  input: ServiceEventInput,
+): Promise<ActionResult<{ event: ServiceEventRow }>> {
+  return withActionContext("service-log-event", async (userId) => {
+    const event = await logServiceEvent(userId, parentType, parentId, input);
+    revalidateItemPath(parentType, parentId);
+    return { ok: true, data: { event } };
+  });
+}
+
+/**
+ * The service-history "Save changes" action: correct an existing event's
+ * date and/or notes (the correction path this unit adds). `eventId` is the
+ * only handle the client has on the target event — no `parentType`/
+ * `parentId` is accepted from it — `updateServiceEvent` resolves the true
+ * parent off the row itself and authorizes against THAT, never a value this
+ * action could otherwise be tricked into trusting. The returned row's own
+ * parent is what's used to revalidate, via `resolveServiceEventParent`.
+ */
+export async function updateServiceEventAction(
+  eventId: string,
+  input: ServiceEventUpdateInput,
+): Promise<ActionResult<{ event: ServiceEventRow }>> {
+  return withActionContext("service-update-event", async (userId) => {
+    const event = await updateServiceEvent(userId, eventId, input);
+    const { parentType, parentId } = resolveServiceEventParent(event);
+    revalidateItemPath(parentType, parentId);
+    return { ok: true, data: { event } };
+  });
+}
+
+/**
+ * The service-history "Delete" action: remove an event outright. Same
+ * caller-supplies-only-an-id shape as `updateServiceEventAction` above —
+ * `deleteServiceEvent` hands back the just-deleted row so this action can
+ * still revalidate the correct detail route despite never having been given
+ * a parent to trust.
+ */
+export async function deleteServiceEventAction(
+  eventId: string,
+): Promise<ActionResult> {
+  return withActionContext("service-delete-event", async (userId) => {
+    const deleted = await deleteServiceEvent(userId, eventId);
+    const { parentType, parentId } = resolveServiceEventParent(deleted);
+    revalidateItemPath(parentType, parentId);
+    return { ok: true };
+  });
+}
+
+/**
+ * The "Override" action: create-or-update this item's thresholds for
+ * `input.name`. Creates a new item-rule row when the item has no entry for
+ * that name yet (an "inherited" rule becoming "overridden"); updates the
+ * existing row otherwise (adjusting an already-overridden rule). `input.name`
+ * is expected already-trimmed (`ServiceRuleForm` trims before calling this) —
+ * `findItemRuleByName` below matches by exact string equality against
+ * already-trimmed stored names, before either branch's own server-side trim
+ * would otherwise run.
+ */
+export async function overrideServiceRuleAction(
+  parentType: ServiceParentType,
+  parentId: string,
+  input: ServiceRuleInput,
+): Promise<ActionResult<{ rule: ServiceRuleRow }>> {
+  return withActionContext("service-override-rule", async (userId) => {
+    const { existing, siblings } = await findItemRuleByName(
+      userId,
+      parentType,
+      parentId,
+      input.name,
+    );
+    const payload: ItemRuleInput = { ...input, suppressed: false };
+    const rule = existing
+      ? await updateItemRule(
+          userId,
+          parentType,
+          parentId,
+          existing.id,
+          payload,
+          siblings,
+        )
+      : await createItemRule(userId, parentType, parentId, payload, siblings);
+    revalidateItemPath(parentType, parentId);
+    return { ok: true, data: { rule } };
+  });
+}
+
+/** The "Add item-only rule" action: a new rule with no matching default. */
+export async function addItemOnlyRuleAction(
+  parentType: ServiceParentType,
+  parentId: string,
+  input: ServiceRuleInput,
+): Promise<ActionResult<{ rule: ServiceRuleRow }>> {
+  return withActionContext("service-add-item-only-rule", async (userId) => {
+    const rule = await createItemRule(userId, parentType, parentId, {
+      ...input,
+      suppressed: false,
+    });
+    revalidateItemPath(parentType, parentId);
+    return { ok: true, data: { rule } };
+  });
+}
+
+/**
+ * Shared delete-by-name core behind two DIFFERENT rule actions that happen to
+ * be the same write: "Reset to inherited" (an overridden rule falling back
+ * to its category default) and "Remove" (an item-only rule, which has no
+ * default underneath to fall back to). Both are
+ * structurally "delete this item's row for `ruleName`"; keeping one function
+ * avoids the two diverging while each call site's own name still says why it
+ * invokes it.
+ */
+async function deleteItemRuleByName(
+  userId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+  ruleName: string,
+): Promise<void> {
+  const { existing } = await findItemRuleByName(
+    userId,
+    parentType,
+    parentId,
+    ruleName,
+  );
+  if (!existing) throw new NotFoundError();
+  await deleteItemRule(userId, parentType, parentId, existing.id);
+  revalidateItemPath(parentType, parentId);
+}
+
+/** The "Reset to inherited" action: delete this item's override for `ruleName`. */
+export async function resetServiceRuleAction(
+  parentType: ServiceParentType,
+  parentId: string,
+  ruleName: string,
+): Promise<ActionResult> {
+  return withActionContext("service-reset-rule", async (userId) => {
+    await deleteItemRuleByName(userId, parentType, parentId, ruleName);
+    return { ok: true };
+  });
+}
+
+/**
+ * The "Remove" action: delete an ITEM-ONLY rule outright. An item-only rule
+ * has no category default underneath it, so
+ * unlike "Reset to inherited" there is nothing left to measure once the row
+ * is gone — this is a real deletion, not a fallback, and the panel's toast
+ * copy says so ("removed", never "restored"/"reset").
+ */
+export async function removeItemOnlyRuleAction(
+  parentType: ServiceParentType,
+  parentId: string,
+  ruleName: string,
+): Promise<ActionResult> {
+  return withActionContext("service-remove-item-only-rule", async (userId) => {
+    await deleteItemRuleByName(userId, parentType, parentId, ruleName);
+    return { ok: true };
+  });
+}
+
+/**
+ * The "Suppress" action: hide `ruleName` from this item's active rule set
+ * without deleting an existing override's row identity — updates it in
+ * place (nulling its thresholds, KTD6) when one exists, else creates a new
+ * suppressed row.
+ */
+export async function suppressServiceRuleAction(
+  parentType: ServiceParentType,
+  parentId: string,
+  ruleName: string,
+): Promise<ActionResult> {
+  return withActionContext("service-suppress-rule", async (userId) => {
+    const { existing, siblings } = await findItemRuleByName(
+      userId,
+      parentType,
+      parentId,
+      ruleName,
+    );
+    if (existing) {
+      await updateItemRule(
+        userId,
+        parentType,
+        parentId,
+        existing.id,
+        { name: ruleName, suppressed: true },
+        siblings,
+      );
+    } else {
+      await createItemRule(
+        userId,
+        parentType,
+        parentId,
+        { name: ruleName, suppressed: true },
+        siblings,
+      );
+    }
+    revalidateItemPath(parentType, parentId);
+    return { ok: true };
+  });
+}
+
+/** The "Restore" action: un-suppress `ruleName` (KTD6 — deleting the row is the restoration). */
+export async function restoreServiceRuleAction(
+  parentType: ServiceParentType,
+  parentId: string,
+  ruleName: string,
+): Promise<ActionResult> {
+  return withActionContext("service-restore-rule", async (userId) => {
+    const { existing } = await findItemRuleByName(
+      userId,
+      parentType,
+      parentId,
+      ruleName,
+    );
+    if (!existing) throw new NotFoundError();
+    await deleteItemRule(userId, parentType, parentId, existing.id);
+    revalidateItemPath(parentType, parentId);
+    return { ok: true };
+  });
+}
diff --git a/app/(app)/firearms/service-history.tsx b/app/(app)/firearms/service-history.tsx
new file mode 100644
index 00000000..bf62b475
--- /dev/null
+++ b/app/(app)/firearms/service-history.tsx
@@ -0,0 +1,329 @@
+"use client";
+
+import { type FormEvent, useId, useState, useTransition } from "react";
+import { Button } from "@/components/ui/button";
+import { DataTable } from "@/components/ui/data-table/data-table";
+import {
+  ACTIONS_COLUMN_ID,
+  type ColumnDef,
+  createDefaultTableViewState,
+} from "@/components/ui/data-table/types";
+import { Callout, EmptyState } from "@/components/ui/feedback";
+import { Field } from "@/components/ui/field";
+import { Input, Textarea } from "@/components/ui/input";
+import { Card } from "@/components/ui/surface";
+import { useToast } from "@/components/ui/toast";
+import { Data } from "@/components/ui/typography";
+import { useTableViewState } from "@/hooks/use-table-view-state";
+import {
+  type ServiceEventUpdateInput,
+  validateServiceEventUpdateInput,
+} from "@/src/domain/service-intervals/validate-event";
+import { firstMessage } from "@/src/domain/validation-messages";
+import {
+  deleteServiceEventAction,
+  updateServiceEventAction,
+} from "./service-actions";
+
+/**
+ * An item's service history (U8, R17) — every service event, newest first,
+ * naming the rule it serviced — plus, for an actor who may write (KTD3), the
+ * correction path this unit adds: edit an event's date/notes, or delete it
+ * outright. Server-loaded and passed in as a prop (the detail page already
+ * loads it alongside the resolved rules in one `Promise.all`, mirroring how
+ * `photos`/`documents` are loaded rather than fetched client-side);
+ * `onChange` (mirroring `RangeSessionHistory`'s convention) lets the parent
+ * `router.refresh()` after an edit or delete so every rule's due state,
+ * derived on read, reflects the correction on the very next render.
+ *
+ * `canWrite` defaults to `false` so a caller that hasn't wired it through yet
+ * renders read-only rather than failing to compile. Both current callers wire
+ * it through: `firearm-detail-view.tsx` passes `canEdit` (owner or
+ * edit-grantee), `accessory-detail-view.tsx` passes `isOwner` (accessories
+ * are owner-only throughout, KTD3).
+ *
+ * R21 (advisory only): no `ConfirmDialog` here. Deleting a service event has
+ * no undo, but this feature is advisory throughout, and every other
+ * destructive-ish action already shipped on this exact surface
+ * (`service-rules-panel.tsx`'s Suppress/Remove) is a direct one-click write
+ * with an immediate toast, never a blocking confirmation — Delete here
+ * matches that, with the `destructive` button variant standing in as the
+ * "this can't be undone" cue instead of an interrupting dialog.
+ */
+
+export interface ServiceHistoryEntry {
+  id: string;
+  ruleName: string;
+  servicedOn: string;
+  actorName: string;
+  notes: string;
+}
+
+interface ServiceHistoryProps {
+  entries: ServiceHistoryEntry[];
+  /**
+   * True when the actor may correct or delete an event here (KTD3): an
+   * edit-grantee or the owner on a firearm; the owner only on an accessory —
+   * the exact same split `logServiceEvent`'s `authorizeEventWrite` enforces
+   * server-side, so this flag only ever hides a control the write would
+   * reject anyway, never grants one.
+   */
+  canWrite?: boolean;
+  /** Called after a successful edit or delete so the parent can
+   * `router.refresh()` for fresh due state (mirrors `RangeSessionHistory`'s
+   * `onChange` convention). */
+  onChange?: () => void;
+}
+
+const DATE_CODES = [
+  "emptyServicedOn",
+  "invalidServicedOn",
+  "servicedOnInFuture",
+];
+
+interface EditServiceEventFormProps {
+  entry: ServiceHistoryEntry;
+  onCancel: () => void;
+  onSaved: () => void;
+}
+
+/**
+ * The inline "Save changes" form behind an entry's "Edit" control. Only
+ * `servicedOn` and `notes` are editable fields — there is no rule-name field
+ * at all, matching `updateServiceEvent`'s contract (an event's rule and
+ * parent are fixed for its whole life; see that function's doc in
+ * `events-service.ts`). Field labels ("Date serviced" / "Notes") match
+ * `log-service-form.tsx`'s exactly, so the correction form reads as the same
+ * kind of control as the original log-service one.
+ */
+function EditServiceEventForm({
+  entry,
+  onCancel,
+  onSaved,
+}: EditServiceEventFormProps) {
+  const [servicedOn, setServicedOn] = useState(entry.servicedOn);
+  const [notes, setNotes] = useState(entry.notes);
+  const [codes, setCodes] = useState<string[]>([]);
+  const [serverError, setServerError] = useState<string | null>(null);
+  const [pending, startTransition] = useTransition();
+  const dateId = useId();
+  const notesId = useId();
+
+  function submit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    const input: ServiceEventUpdateInput = { servicedOn, notes };
+    const found = validateServiceEventUpdateInput(input);
+    setCodes(found);
+    setServerError(null);
+    if (found.length > 0) {
+      document.getElementById(dateId)?.focus();
+      return;
+    }
+    startTransition(async () => {
+      const result = await updateServiceEventAction(entry.id, input);
+      if (result.ok) {
+        onSaved();
+      } else if (result.codes) {
+        setCodes(result.codes);
+      } else {
+        setServerError(result.error ?? "Could not save changes.");
+      }
+    });
+  }
+
+  return (
+    <form
+      onSubmit={submit}
+      aria-label={`Edit service — ${entry.ruleName}, ${entry.servicedOn}`}
+      className="flex flex-col gap-3 rounded-md border border-input p-3"
+      noValidate
+    >
+      {serverError ? <Callout tone="destructive">{serverError}</Callout> : null}
+      <Field
+        label="Date serviced"
+        controlId={dateId}
+        required
+        error={firstMessage(codes, DATE_CODES)}
+      >
+        <Input
+          id={dateId}
+          type="date"
+          value={servicedOn}
+          onChange={(e) => setServicedOn(e.target.value)}
+          aria-invalid={DATE_CODES.some((c) => codes.includes(c))}
+        />
+      </Field>
+      <Field label="Notes" controlId={notesId}>
+        <Textarea
+          id={notesId}
+          value={notes}
+          onChange={(e) => setNotes(e.target.value)}
+        />
+      </Field>
+      <div className="flex items-center gap-2">
+        <Button type="submit" size="sm" disabled={pending}>
+          {pending ? "Saving…" : "Save changes"}
+        </Button>
+        <Button
+          type="button"
+          variant="ghost"
+          size="sm"
+          onClick={onCancel}
+          disabled={pending}
+        >
+          Cancel
+        </Button>
+      </div>
+    </form>
+  );
+}
+
+export function ServiceHistory({
+  entries,
+  canWrite = false,
+  onChange,
+}: ServiceHistoryProps) {
+  const { toast } = useToast();
+  const [editingId, setEditingId] = useState<string | null>(null);
+  const [deletingId, setDeletingId] = useState<string | null>(null);
+  const [deletePending, startDelete] = useTransition();
+
+  function afterMutation(message: string) {
+    setEditingId(null);
+    toast({ message });
+    onChange?.();
+  }
+
+  function remove(entry: ServiceHistoryEntry) {
+    setDeletingId(entry.id);
+    startDelete(async () => {
+      const result = await deleteServiceEventAction(entry.id);
+      setDeletingId(null);
+      if (result.ok) {
+        afterMutation(`${entry.ruleName} entry deleted`);
+      } else {
+        toast({
+          message: result.error ?? "Could not delete.",
+          tone: "destructive",
+        });
+      }
+    });
+  }
+
+  // Not memoized: `useTableViewState` only ever reads its `defaults` argument
+  // once, on first render, via an internal ref (see its own doc) — so a fresh
+  // `columns` array each render costs nothing beyond this small, bounded
+  // (per-item) history list and avoids depending on `remove`/`afterMutation`,
+  // which close over state that changes every render anyway.
+  function buildColumns(): ColumnDef<ServiceHistoryEntry>[] {
+    const cols: ColumnDef<ServiceHistoryEntry>[] = [
+      {
+        accessorKey: "servicedOn",
+        id: "servicedOn",
+        header: "Date",
+        meta: { label: "Date" },
+        cell: ({ getValue }) => <Data>{getValue<string>()}</Data>,
+      },
+      {
+        accessorKey: "ruleName",
+        id: "ruleName",
+        header: "Rule",
+        meta: { label: "Rule" },
+      },
+      {
+        accessorKey: "actorName",
+        id: "actorName",
+        header: "Serviced by",
+        meta: { label: "Serviced by" },
+      },
+      {
+        accessorKey: "notes",
+        id: "notes",
+        header: "Notes",
+        meta: { label: "Notes" },
+        cell: ({ getValue }) => (
+          <span className="text-ink-soft">{getValue<string>()}</span>
+        ),
+      },
+    ];
+    if (canWrite) {
+      cols.push({
+        id: ACTIONS_COLUMN_ID,
+        header: () => <span className="sr-only">Actions</span>,
+        enableSorting: false,
+        enableHiding: false,
+        cell: ({ row }) => {
+          const entry = row.original;
+          const isDeleting = deletePending && deletingId === entry.id;
+          return (
+            <div className="flex justify-end gap-1">
+              <Button
+                variant="ghost"
+                size="sm"
+                onClick={() => setEditingId(entry.id)}
+                aria-label={`Edit service — ${entry.ruleName}, ${entry.servicedOn}`}
+              >
+                Edit
+              </Button>
+              <Button
+                variant="destructive"
+                size="sm"
+                onClick={() => remove(entry)}
+                disabled={isDeleting}
+                aria-label={`Delete service — ${entry.ruleName}, ${entry.servicedOn}`}
+              >
+                {isDeleting ? "Deleting…" : "Delete"}
+              </Button>
+            </div>
+          );
+        },
+      });
+    }
+    return cols;
+  }
+
+  const columns = buildColumns();
+
+  const { viewState, setViewState, mounted } = useTableViewState(
+    "service-history",
+    createDefaultTableViewState(columns),
+  );
+
+  const editingEntry = canWrite
+    ? (entries.find((entry) => entry.id === editingId) ?? null)
+    : null;
+
+  return (
+    <Card role="region" aria-label="Service history">
+      <h2 className="mb-4 text-sm font-semibold text-foreground">
+        Service history
+      </h2>
+      {editingEntry ? (
+        <div className="mb-4">
+          <EditServiceEventForm
+            key={editingEntry.id}
+            entry={editingEntry}
+            onCancel={() => setEditingId(null)}
+            onSaved={() =>
+              afterMutation(`${editingEntry.ruleName} entry updated`)
+            }
+          />
+        </div>
+      ) : null}
+      {entries.length === 0 ? (
+        <EmptyState
+          title="No service logged yet"
+          description="Logged service against any rule will appear here, newest first."
+        />
+      ) : (
+        <DataTable
+          columns={columns}
+          data={entries}
+          viewState={viewState}
+          onViewStateChange={setViewState}
+          mounted={mounted}
+        />
+      )}
+    </Card>
+  );
+}
diff --git a/app/(app)/firearms/service-rules-panel.tsx b/app/(app)/firearms/service-rules-panel.tsx
new file mode 100644
index 00000000..a82dc764
--- /dev/null
+++ b/app/(app)/firearms/service-rules-panel.tsx
@@ -0,0 +1,473 @@
+"use client";
+
+import Link from "next/link";
+import { Fragment, useState, useTransition } from "react";
+import { ServiceRuleForm } from "@/app/(app)/settings/service/default-rule-form";
+import { Button } from "@/components/ui/button";
+import { Badge, EmptyState } from "@/components/ui/feedback";
+import { Card } from "@/components/ui/surface";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/ui/table";
+import { useToast } from "@/components/ui/toast";
+import type { ActionResult } from "@/src/domain/action-result";
+import type { InheritanceState } from "@/src/domain/service-intervals/constants";
+import type { RuleDueState } from "@/src/domain/service-intervals/due-service";
+import type { ServiceParentType } from "@/src/domain/service-intervals/rules-service";
+import { LogServiceForm } from "./log-service-form";
+import {
+  addItemOnlyRuleAction,
+  logServiceEventAction,
+  overrideServiceRuleAction,
+  removeItemOnlyRuleAction,
+  resetServiceRuleAction,
+  restoreServiceRuleAction,
+  suppressServiceRuleAction,
+} from "./service-actions";
+
+/**
+ * The shared service-rules panel (U8, R18) — ONE component mounted on both
+ * the firearm and accessory detail views, taking the item's resolved,
+ * due-annotated rules as props (`getItemDueState`'s output, U4's
+ * derivation — no re-deriving here, KTD4). Nothing in this file decides due
+ * state; it only renders what was already computed and dispatches the five
+ * rule actions plus log-service.
+ *
+ * Permission gating (KTD3): `canManageRules` gates all five rule actions;
+ * `canLogService` gates only the log-service action. A firearm view-grantee
+ * gets neither; a firearm edit-grantee gets `canLogService` only; every
+ * owner gets both; an accessory is owner-only throughout, so both flags are
+ * identical there and a non-owner never even reaches this component (the
+ * accessory detail page doesn't load or mount it for them).
+ *
+ * R21: no action here confirms, interrupts, or blocks — reset/suppress/
+ * restore are direct one-click writes with no `ConfirmDialog`, and a due
+ * rule renders as a plain text marker, never a modal.
+ */
+
+const INHERITANCE_LABEL: Record<InheritanceState, string> = {
+  inherited: "Inherited",
+  overridden: "Overridden",
+  "item-only": "Item-only",
+};
+
+function formatAxis(
+  elapsed: number,
+  threshold: number | null,
+  unit: string,
+): string {
+  if (threshold === null) return "—";
+  const label = threshold === 1 ? unit.replace(/s$/, "") : unit;
+  return `${elapsed} of ${threshold} ${label}`;
+}
+
+export interface ServiceRulesPanelProps {
+  parentType: ServiceParentType;
+  parentId: string;
+  rules: RuleDueState[];
+  /** Names of this item's suppressed rules (KTD6) — absent from `rules` entirely (R5). */
+  suppressedRuleNames: string[];
+  /** Owner-only: override, reset, suppress, restore, add-item-only (KTD3). */
+  canManageRules: boolean;
+  /** Owner or edit-grantee on a firearm; owner-only on an accessory (KTD3). */
+  canLogService: boolean;
+  /** Called after any mutation so the parent can `router.refresh()` for fresh due state. */
+  onChange: () => void;
+}
+
+type PanelForm =
+  | { kind: "override"; rule: RuleDueState }
+  | { kind: "addItemOnly" }
+  | { kind: "log"; ruleName: string }
+  | null;
+
+function toRuleFieldValues(rule: RuleDueState) {
+  return {
+    name: rule.name,
+    days: rule.intervalDays?.toString() ?? "",
+    sessions: rule.intervalSessions?.toString() ?? "",
+    rounds: rule.intervalRounds?.toString() ?? "",
+  };
+}
+
+interface RuleActionsProps {
+  rule: RuleDueState;
+  canManageRules: boolean;
+  canLogService: boolean;
+  onOverride: () => void;
+  onLog: () => void;
+  onReset: () => void;
+  onSuppress: () => void;
+  onRemove: () => void;
+  pending: boolean;
+}
+
+function RuleActions({
+  rule,
+  canManageRules,
+  canLogService,
+  onOverride,
+  onLog,
+  onReset,
+  onSuppress,
+  onRemove,
+  pending,
+}: RuleActionsProps) {
+  // An item-only rule has no category default underneath it, so "Suppress"
+  // (mask an inherited default) has nothing to mask — offer "Remove" (delete
+  // the row outright) instead, so the removal path this action was always
+  // the only way to reach doesn't silently destroy an item-only rule's
+  // thresholds behind a button and toast that both say "restored". Suppress
+  // stays exactly as-is for an inherited or overridden rule.
+  const isItemOnly = rule.inheritanceState === "item-only";
+
+  return (
+    <div className="flex flex-wrap justify-end gap-1">
+      {canLogService ? (
+        <Button
+          variant="ghost"
+          size="sm"
+          onClick={onLog}
+          aria-label={`Log service — ${rule.name}`}
+        >
+          Log service
+        </Button>
+      ) : null}
+      {canManageRules ? (
+        <>
+          {!isItemOnly ? (
+            <Button
+              variant="ghost"
+              size="sm"
+              onClick={onOverride}
+              aria-label={`Override ${rule.name}`}
+            >
+              Override
+            </Button>
+          ) : null}
+          {rule.inheritanceState === "overridden" ? (
+            <Button
+              variant="ghost"
+              size="sm"
+              onClick={onReset}
+              disabled={pending}
+              aria-label={`Reset ${rule.name} to inherited`}
+            >
+              Reset to inherited
+            </Button>
+          ) : null}
+          {isItemOnly ? (
+            <Button
+              variant="ghost"
+              size="sm"
+              onClick={onRemove}
+              disabled={pending}
+              aria-label={`Remove ${rule.name}`}
+            >
+              Remove
+            </Button>
+          ) : (
+            <Button
+              variant="ghost"
+              size="sm"
+              onClick={onSuppress}
+              disabled={pending}
+              aria-label={`Suppress ${rule.name}`}
+            >
+              Suppress
+            </Button>
+          )}
+        </>
+      ) : null}
+    </div>
+  );
+}
+
+export function ServiceRulesPanel({
+  parentType,
+  parentId,
+  rules,
+  suppressedRuleNames,
+  canManageRules,
+  canLogService,
+  onChange,
+}: ServiceRulesPanelProps) {
+  const { toast } = useToast();
+  const [form, setForm] = useState<PanelForm>(null);
+  const [pending, startTransition] = useTransition();
+
+  function afterMutation(message?: string) {
+    setForm(null);
+    if (message) toast({ message });
+    onChange();
+  }
+
+  function siblingNamesExcluding(name: string): string[] {
+    const active = rules.map((r) => r.name).filter((n) => n !== name);
+    const suppressed = suppressedRuleNames.filter((n) => n !== name);
+    return [...active, ...suppressed];
+  }
+
+  /**
+   * Shared shape behind all four rule actions below: run in a transition,
+   * toast a success message and refresh via `afterMutation` on success, or
+   * toast `result.error` (or a fallback) with the destructive tone on
+   * failure. Each call site supplies its own action and message text — only
+   * the duplicated control flow is collapsed here.
+   */
+  function runRuleAction(
+    action: () => Promise<ActionResult>,
+    success: string,
+    failure: string,
+  ) {
+    startTransition(async () => {
+      const result = await action();
+      if (result.ok) {
+        afterMutation(success);
+      } else {
+        toast({ message: result.error ?? failure, tone: "destructive" });
+      }
+    });
+  }
+
+  function reset(ruleName: string) {
+    runRuleAction(
+      () => resetServiceRuleAction(parentType, parentId, ruleName),
+      `${ruleName} reset to inherited`,
+      "Could not reset rule.",
+    );
+  }
+
+  function suppress(ruleName: string) {
+    runRuleAction(
+      () => suppressServiceRuleAction(parentType, parentId, ruleName),
+      `${ruleName} suppressed`,
+      "Could not suppress rule.",
+    );
+  }
+
+  function restore(ruleName: string) {
+    runRuleAction(
+      () => restoreServiceRuleAction(parentType, parentId, ruleName),
+      `${ruleName} restored`,
+      "Could not restore rule.",
+    );
+  }
+
+  /**
+   * The "Remove" action for an item-only rule: a real deletion, not a
+   * fallback — an item-only rule has no category default underneath it to
+   * fall back to, so the toast says "removed", never "restored".
+   */
+  function remove(ruleName: string) {
+    runRuleAction(
+      () => removeItemOnlyRuleAction(parentType, parentId, ruleName),
+      `${ruleName} removed`,
+      "Could not remove rule.",
+    );
+  }
+
+  const isEmpty = rules.length === 0 && suppressedRuleNames.length === 0;
+
+  return (
+    <Card role="region" aria-label="Service rules">
+      <div className="mb-4 flex flex-wrap items-start justify-between gap-3">
+        <h2 className="text-sm font-semibold text-foreground">Service rules</h2>
+        {canManageRules && form?.kind !== "addItemOnly" ? (
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() => setForm({ kind: "addItemOnly" })}
+          >
+            Add item-only rule
+          </Button>
+        ) : null}
+      </div>
+
+      {isEmpty ? (
+        <EmptyState
+          title="No service rules"
+          description={
+            canManageRules
+              ? "Set up category defaults so every matching item inherits them, or add an item-only rule below."
+              : "No service rules are tracked for this item."
+          }
+          action={
+            canManageRules ? (
+              <Link
+                href="/settings/service"
+                className="text-sm font-medium text-primary hover:underline"
+              >
+                Go to Service defaults
+              </Link>
+            ) : undefined
+          }
+        />
+      ) : (
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHead>Rule</TableHead>
+              <TableHead>State</TableHead>
+              <TableHead>Days</TableHead>
+              <TableHead>Sessions</TableHead>
+              <TableHead>Rounds</TableHead>
+              <TableHead>
+                <span className="sr-only">Actions</span>
+              </TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {rules.map((rule) => {
+              const isOverrideForm =
+                form?.kind === "override" && form.rule.name === rule.name;
+              const isLogForm =
+                form?.kind === "log" && form.ruleName === rule.name;
+              return (
+                <Fragment key={rule.name}>
+                  {isOverrideForm ? (
+                    <TableRow key={`${rule.name}-override`}>
+                      <TableCell colSpan={6}>
+                        <ServiceRuleForm
+                          initial={toRuleFieldValues(rule)}
+                          nameLocked={rule.inheritanceState !== "item-only"}
+                          siblingNames={siblingNamesExcluding(rule.name)}
+                          submitLabel="Save override"
+                          pendingLabel="Saving…"
+                          onCancel={() => setForm(null)}
+                          onSubmit={(input) =>
+                            overrideServiceRuleAction(
+                              parentType,
+                              parentId,
+                              input,
+                            )
+                          }
+                          onSaved={() => afterMutation(`${rule.name} updated`)}
+                        />
+                      </TableCell>
+                    </TableRow>
+                  ) : (
+                    <TableRow key={rule.name}>
+                      <TableCell className="font-medium text-foreground">
+                        {rule.name}
+                      </TableCell>
+                      <TableCell>
+                        <div className="flex flex-wrap items-center gap-1.5">
+                          <Badge tone="neutral">
+                            {INHERITANCE_LABEL[rule.inheritanceState]}
+                          </Badge>
+                          {rule.due ? (
+                            <Badge tone="destructive">Due</Badge>
+                          ) : null}
+                        </div>
+                      </TableCell>
+                      <TableCell>
+                        {formatAxis(
+                          rule.counts.days,
+                          rule.intervalDays,
+                          "days",
+                        )}
+                      </TableCell>
+                      <TableCell>
+                        {formatAxis(
+                          rule.counts.sessions,
+                          rule.intervalSessions,
+                          "sessions",
+                        )}
+                      </TableCell>
+                      <TableCell>
+                        {formatAxis(
+                          rule.counts.rounds,
+                          rule.intervalRounds,
+                          "rounds",
+                        )}
+                      </TableCell>
+                      <TableCell>
+                        <RuleActions
+                          rule={rule}
+                          canManageRules={canManageRules}
+                          canLogService={canLogService}
+                          pending={pending}
+                          onOverride={() => setForm({ kind: "override", rule })}
+                          onLog={() =>
+                            setForm({ kind: "log", ruleName: rule.name })
+                          }
+                          onReset={() => reset(rule.name)}
+                          onSuppress={() => suppress(rule.name)}
+                          onRemove={() => remove(rule.name)}
+                        />
+                      </TableCell>
+                    </TableRow>
+                  )}
+                  {isLogForm ? (
+                    <TableRow key={`${rule.name}-log`}>
+                      <TableCell colSpan={6}>
+                        <LogServiceForm
+                          ruleName={rule.name}
+                          onCancel={() => setForm(null)}
+                          onSubmit={(input) =>
+                            logServiceEventAction(parentType, parentId, input)
+                          }
+                          onSaved={() =>
+                            afterMutation(`Logged service — ${rule.name}`)
+                          }
+                        />
+                      </TableCell>
+                    </TableRow>
+                  ) : null}
+                </Fragment>
+              );
+            })}
+          </TableBody>
+        </Table>
+      )}
+
+      {form?.kind === "addItemOnly" ? (
+        <div className="mt-3">
+          <ServiceRuleForm
+            siblingNames={[...rules.map((r) => r.name), ...suppressedRuleNames]}
+            submitLabel="Add rule"
+            pendingLabel="Adding…"
+            onCancel={() => setForm(null)}
+            onSubmit={(input) =>
+              addItemOnlyRuleAction(parentType, parentId, input)
+            }
+            onSaved={() => afterMutation("Item-only rule added")}
+          />
+        </div>
+      ) : null}
+
+      {canManageRules && suppressedRuleNames.length > 0 ? (
+        <div className="mt-4 border-t border-border pt-4">
+          <h3 className="mb-2 text-xs font-semibold uppercase tracking-wide text-muted-foreground">
+            Suppressed rules
+          </h3>
+          <ul className="flex flex-col gap-1.5">
+            {suppressedRuleNames.map((name) => (
+              <li
+                key={name}
+                className="flex items-center justify-between gap-3 text-sm"
+              >
+                <span className="text-foreground">{name}</span>
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  onClick={() => restore(name)}
+                  disabled={pending}
+                  aria-label={`Restore ${name}`}
+                >
+                  Restore
+                </Button>
+              </li>
+            ))}
+          </ul>
+        </div>
+      ) : null}
+    </Card>
+  );
+}
diff --git a/app/(app)/inventory-log/log-entry-form.tsx b/app/(app)/inventory-log/log-entry-form.tsx
index f38fb4eb..bdd52b08 100644
--- a/app/(app)/inventory-log/log-entry-form.tsx
+++ b/app/(app)/inventory-log/log-entry-form.tsx
@@ -22,7 +22,7 @@ import { logEventAction } from "./log-actions";
 const EVENT_TYPE_CODES = ["invalidEventType", "invalidParentType"];
 const OCCURRED_AT_CODES = ["occurredAtInFuture", "invalidOccurredAt"];
 
-/** Display label for a stored event type ("cleaned" -> "Cleaned"). */
+/** Display label for a stored event type ("inventoried" -> "Inventoried"). */
 export function eventTypeLabel(value: string): string {
   return value.length > 0 ? value[0].toUpperCase() + value.slice(1) : value;
 }
@@ -41,7 +41,7 @@ function nowLocal(): string {
 interface LogEntryFormProps {
   parentType: ParentType;
   parentId: string;
-  /** The parent-appropriate event-type set (R11) — firearm surfaces maintenance types. */
+  /** The parent-appropriate event-type set (R11) — since U5 retired `cleaned`/`lubed`, both parent families offer only "inventoried". */
   eventTypes: readonly EventType[];
   onDone: () => void;
   onCancel: () => void;
diff --git a/app/(app)/settings/page.tsx b/app/(app)/settings/page.tsx
index 2eaed9cb..86077b7c 100644
--- a/app/(app)/settings/page.tsx
+++ b/app/(app)/settings/page.tsx
@@ -1,5 +1,7 @@
+import Link from "next/link";
 import { redirect } from "next/navigation";
-import { PageHeader } from "@/components/ui/surface";
+import { buttonVariants } from "@/components/ui/button";
+import { Card, PageHeader } from "@/components/ui/surface";
 import { getCurrentUser } from "@/src/auth/session";
 import { SettingsForm } from "./settings-form";
 
@@ -14,6 +16,26 @@ export default async function SettingsPage() {
         description="Manage your account preferences."
       />
       <SettingsForm magpulMode={user.magpulMode} />
+      <Card>
+        <h2 className="text-sm font-semibold text-foreground">
+          Service intervals
+        </h2>
+        <p className="mt-1.5 text-sm text-ink-soft">
+          Set default cleaning, barrel, and other service rules per firearm type
+          and accessory category. Every item in that category inherits the
+          defaults live — none of them need to be visited.
+        </p>
+        <Link
+          href="/settings/service"
+          className={buttonVariants({
+            variant: "outline",
+            size: "sm",
+            className: "mt-4",
+          })}
+        >
+          Manage service-interval defaults
+        </Link>
+      </Card>
     </div>
   );
 }
diff --git a/app/(app)/settings/service/__tests__/actions.test.ts b/app/(app)/settings/service/__tests__/actions.test.ts
new file mode 100644
index 00000000..ebfa4436
--- /dev/null
+++ b/app/(app)/settings/service/__tests__/actions.test.ts
@@ -0,0 +1,319 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+import { NotAuthorizedError, NotFoundError } from "@/src/auth/errors";
+import { ValidationError } from "@/src/domain/errors";
+import type {
+  ServiceRuleDefaultInput,
+  ServiceRuleDefaultRow,
+  ServiceRuleDefaultUpdateInput,
+} from "@/src/domain/service-intervals/rules-service";
+import * as rulesService from "@/src/domain/service-intervals/rules-service";
+
+/**
+ * Server-action unit tests for the service-defaults settings surface (U7).
+ * Mocks the session (`mock.module`, mirroring
+ * `app/(app)/firearms/__tests__/documents-actions.test.ts`) rather than
+ * hitting the DB — this only exercises the `"use server"` action boundary:
+ * auth gating and `ActionResult` mapping. Rules-service behavior itself
+ * (validation, owner-scoping, duplicate names) is covered by
+ * `src/domain/service-intervals/__tests__/rules-service.test.ts`.
+ *
+ * The three default-CRUD functions are `spyOn`-stubbed on the REAL
+ * `rules-service` module namespace rather than `mock.module`-replaced: a
+ * `mock.module` factory here can only export the handful of functions this
+ * file cares about, and that narrow shape then "wins" for every other file's
+ * import of the same specifier for the rest of the `bun test` process
+ * (confirmed by direct repro, mirrors the tradeoff documented in
+ * `firearms/__tests__/service-actions.test.ts`) — including
+ * `accessories/[id]/__tests__/service-props.test.ts`, whose imported
+ * `due-service.ts` statically imports OTHER rules-service exports
+ * (`loadItemRules`, `requireAccessoryOwner`) that a narrow mock omits
+ * entirely, breaking that file's import at load time. `spyOn` overrides only
+ * the three named exports this file needs, leaving the rest of the module's
+ * real surface intact for everyone else.
+ */
+
+let currentUserId: string | null = null;
+mock.module("@/src/auth/session", () => ({
+  getCurrentUser: async () => (currentUserId ? { id: currentUserId } : null),
+}));
+
+interface CreateCall {
+  actorId: string;
+  input: ServiceRuleDefaultInput;
+}
+let createCalls: CreateCall[] = [];
+let createResult: ServiceRuleDefaultRow = {
+  id: "default-1",
+} as ServiceRuleDefaultRow;
+let createThrows: unknown = null;
+
+interface UpdateCall {
+  actorId: string;
+  id: string;
+  input: ServiceRuleDefaultUpdateInput;
+}
+let updateCalls: UpdateCall[] = [];
+let updateResult: ServiceRuleDefaultRow = {
+  id: "default-1",
+} as ServiceRuleDefaultRow;
+let updateThrows: unknown = null;
+
+interface DeleteCall {
+  actorId: string;
+  id: string;
+}
+let deleteCalls: DeleteCall[] = [];
+let deleteThrows: unknown = null;
+
+let createSpy: ReturnType<typeof spyOn>;
+let updateSpy: ReturnType<typeof spyOn>;
+let deleteSpy: ReturnType<typeof spyOn>;
+
+// Server actions revalidate on every mutation; a bare bun test has no Next.js
+// request/render context for this to hook into (mirrors documents-actions.test.ts).
+let revalidateCalls: string[] = [];
+mock.module("next/cache", () => ({
+  revalidatePath: (path: string) => {
+    revalidateCalls.push(path);
+  },
+}));
+
+const {
+  createServiceRuleDefaultAction,
+  deleteServiceRuleDefaultAction,
+  updateServiceRuleDefaultAction,
+} = await import("../actions");
+
+beforeEach(() => {
+  currentUserId = null;
+  createCalls = [];
+  createResult = { id: "default-1" } as ServiceRuleDefaultRow;
+  createThrows = null;
+  updateCalls = [];
+  updateResult = { id: "default-1" } as ServiceRuleDefaultRow;
+  updateThrows = null;
+  deleteCalls = [];
+  deleteThrows = null;
+  revalidateCalls = [];
+
+  createSpy = spyOn(
+    rulesService,
+    "createServiceRuleDefault",
+  ).mockImplementation(
+    async (actorId: string, input: ServiceRuleDefaultInput) => {
+      createCalls.push({ actorId, input });
+      if (createThrows) throw createThrows;
+      return createResult;
+    },
+  );
+  updateSpy = spyOn(
+    rulesService,
+    "updateServiceRuleDefault",
+  ).mockImplementation(
+    async (
+      actorId: string,
+      id: string,
+      input: ServiceRuleDefaultUpdateInput,
+    ) => {
+      updateCalls.push({ actorId, id, input });
+      if (updateThrows) throw updateThrows;
+      return updateResult;
+    },
+  );
+  deleteSpy = spyOn(
+    rulesService,
+    "deleteServiceRuleDefault",
+  ).mockImplementation(async (actorId: string, id: string) => {
+    deleteCalls.push({ actorId, id });
+    if (deleteThrows) throw deleteThrows;
+  });
+});
+
+// `bun test app` runs every file in one process and Bun's `spyOn`
+// replacements persist until restored, so an unrestored spy here would leak
+// into whichever file runs next.
+afterEach(() => {
+  createSpy.mockRestore();
+  updateSpy.mockRestore();
+  deleteSpy.mockRestore();
+});
+
+const SAMPLE_INPUT: ServiceRuleDefaultInput = {
+  scope: "firearm",
+  category: "rifle",
+  name: "Cleaning",
+  intervalRounds: 500,
+};
+
+describe("createServiceRuleDefaultAction", () => {
+  test("covers: a signed-out request to the settings action is rejected", async () => {
+    currentUserId = null;
+
+    const result = await createServiceRuleDefaultAction(SAMPLE_INPUT);
+
+    expect(result.ok).toBe(false);
+    expect(createCalls).toHaveLength(0);
+  });
+
+  test("forwards the resolved actor id and input to the service, and revalidates on success", async () => {
+    currentUserId = "user-1";
+
+    const result = await createServiceRuleDefaultAction(SAMPLE_INPUT);
+
+    expect(result.ok).toBe(true);
+    expect(createCalls).toEqual([{ actorId: "user-1", input: SAMPLE_INPUT }]);
+    expect(revalidateCalls).toContain("/settings/service");
+  });
+
+  test("maps a ValidationError (empty name, no threshold, duplicate name) to a failed ActionResult with codes, and does not revalidate", async () => {
+    currentUserId = "user-1";
+    createThrows = new ValidationError(["duplicateName"]);
+
+    const result = await createServiceRuleDefaultAction(SAMPLE_INPUT);
+
+    expect(result.ok).toBe(false);
+    expect(result.ok === false && result.codes).toEqual(["duplicateName"]);
+    expect(revalidateCalls).toHaveLength(0);
+  });
+
+  // A malformed payload (`null` here — same as any non-object a client could
+  // send in place of the real shape) must produce the normal failed
+  // ActionResult, not an unhandled TypeError from reading `.scope` off it.
+  test("a malformed non-object payload is rejected as a failed ActionResult, without reaching the service", async () => {
+    currentUserId = "user-1";
+
+    const result = await createServiceRuleDefaultAction(
+      null as unknown as ServiceRuleDefaultInput,
+    );
+
+    expect(result.ok).toBe(false);
+    expect(result.ok === false && result.codes).toEqual(["invalidPayload"]);
+    expect(createCalls).toHaveLength(0);
+  });
+});
+
+describe("updateServiceRuleDefaultAction", () => {
+  test("rejects an unauthenticated caller without touching the service", async () => {
+    currentUserId = null;
+
+    const result = await updateServiceRuleDefaultAction("default-1", {
+      name: "Cleaning",
+      intervalRounds: 600,
+    });
+
+    expect(result.ok).toBe(false);
+    expect(updateCalls).toHaveLength(0);
+  });
+
+  test("forwards the resolved actor id, default id, and input to the service", async () => {
+    currentUserId = "user-1";
+    const input: ServiceRuleDefaultUpdateInput = {
+      name: "Cleaning",
+      intervalRounds: 600,
+    };
+
+    const result = await updateServiceRuleDefaultAction("default-1", input);
+
+    expect(result.ok).toBe(true);
+    expect(updateCalls).toEqual([
+      { actorId: "user-1", id: "default-1", input },
+    ]);
+    expect(revalidateCalls).toContain("/settings/service");
+  });
+
+  test("maps a NotFoundError (another owner's default) to a non-leaking failed ActionResult", async () => {
+    currentUserId = "user-1";
+    updateThrows = new NotFoundError();
+
+    const result = await updateServiceRuleDefaultAction("default-1", {
+      name: "Cleaning",
+      intervalRounds: 600,
+    });
+
+    expect(result.ok).toBe(false);
+  });
+
+  test("maps a NotAuthorizedError to a non-leaking failed ActionResult", async () => {
+    currentUserId = "user-1";
+    updateThrows = new NotAuthorizedError();
+
+    const result = await updateServiceRuleDefaultAction("default-1", {
+      name: "Cleaning",
+      intervalRounds: 600,
+    });
+
+    expect(result.ok).toBe(false);
+  });
+
+  // Consistency gap this suite guards against: only the create action had
+  // this guard previously — update read `input.name.trim()` unguarded, which
+  // throws a raw TypeError on a malformed (`null`) payload instead of the
+  // normal failed ActionResult every other malformed submission takes.
+  test("a malformed non-object payload is rejected as a failed ActionResult, without reaching the service", async () => {
+    currentUserId = "user-1";
+
+    const result = await updateServiceRuleDefaultAction(
+      "default-1",
+      null as unknown as ServiceRuleDefaultUpdateInput,
+    );
+
+    expect(result.ok).toBe(false);
+    expect(result.ok === false && result.codes).toEqual(["invalidPayload"]);
+    expect(updateCalls).toHaveLength(0);
+  });
+});
+
+describe("deleteServiceRuleDefaultAction", () => {
+  test("rejects an unauthenticated caller without touching the service", async () => {
+    currentUserId = null;
+
+    const result = await deleteServiceRuleDefaultAction("default-1");
+
+    expect(result.ok).toBe(false);
+    expect(deleteCalls).toHaveLength(0);
+  });
+
+  test("calls deleteServiceRuleDefault with the resolved actor and given id, and revalidates", async () => {
+    currentUserId = "user-1";
+
+    const result = await deleteServiceRuleDefaultAction("default-1");
+
+    expect(result.ok).toBe(true);
+    expect(deleteCalls).toEqual([{ actorId: "user-1", id: "default-1" }]);
+    expect(revalidateCalls).toContain("/settings/service");
+  });
+
+  test("maps a NotFoundError (another owner's default) to a non-leaking failed ActionResult and does not revalidate", async () => {
+    currentUserId = "user-1";
+    deleteThrows = new NotFoundError();
+
+    const result = await deleteServiceRuleDefaultAction("default-1");
+
+    expect(result.ok).toBe(false);
+    expect(revalidateCalls).toEqual([]);
+  });
+
+  // Delete's payload IS the id (no wrapping object) — a non-string id (a
+  // client sending `null` in its place) would otherwise reach
+  // `deleteServiceRuleDefault` and only fail deep inside the query, rather
+  // than at this boundary like the other two actions' malformed-payload case.
+  test("a non-string id is rejected as a failed ActionResult, without reaching the service", async () => {
+    currentUserId = "user-1";
+
+    const result = await deleteServiceRuleDefaultAction(
+      null as unknown as string,
+    );
+
+    expect(result.ok).toBe(false);
+    expect(result.ok === false && result.codes).toEqual(["invalidPayload"]);
+    expect(deleteCalls).toHaveLength(0);
+  });
+});
diff --git a/app/(app)/settings/service/actions.ts b/app/(app)/settings/service/actions.ts
new file mode 100644
index 00000000..a0e096e8
--- /dev/null
+++ b/app/(app)/settings/service/actions.ts
@@ -0,0 +1,127 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import type { ActionResult } from "@/src/domain/action-result";
+import {
+  createServiceRuleDefault,
+  deleteServiceRuleDefault,
+  type ServiceRuleDefaultInput,
+  type ServiceRuleDefaultRow,
+  type ServiceRuleDefaultUpdateInput,
+  type ServiceScope,
+  updateServiceRuleDefault,
+} from "@/src/domain/service-intervals/rules-service";
+import { withActionContext } from "@/src/lib/logging/entry-context";
+
+/**
+ * Server actions for the service-defaults settings surface (U7). Every
+ * default write here is owner-only by construction — `createServiceRuleDefault`
+ * / `updateServiceRuleDefault` / `deleteServiceRuleDefault` (`rules-service.ts`,
+ * U3) key every read and write on the resolved actor id, never a client-
+ * supplied owner (KTD3). `withActionContext` resolves that actor from the
+ * session and rejects an unauthenticated caller before any of them run.
+ */
+
+function revalidateServiceDefaultsPath(): void {
+  revalidatePath("/settings/service");
+}
+
+const VALID_SERVICE_SCOPES = new Set<ServiceScope>(["firearm", "accessory"]);
+
+/**
+ * Server-action input arrives as deserialized client JSON with no runtime
+ * type guarantee — the `ServiceRuleDefaultInput` / `...UpdateInput` types
+ * only hold at compile time. A malformed payload (`null`, a bare string, a
+ * number — anything a client could send in place of a real object) would
+ * otherwise throw a raw `TypeError` reading a property off it, escaping the
+ * action as an unhandled exception instead of the normal
+ * `ValidationError`/`{ ok: false, codes }` path every other malformed
+ * submission takes. `isPlainObjectPayload` is the shared first check every
+ * object-shaped action input runs through before any property read.
+ */
+function isPlainObjectPayload(
+  input: unknown,
+): input is Record<string, unknown> {
+  return typeof input === "object" && input !== null;
+}
+
+/**
+ * Full-shape guard for create: a malformed `scope` would otherwise reach
+ * `createServiceRuleDefault` and fail at the DB CHECK constraint instead of a
+ * clean validation error; `category`/`name` are only checked for their
+ * runtime type here (`category` stays free text by design — never validate
+ * its VALUE against a fixed list).
+ */
+function validateServiceRuleDefaultInput(
+  input: ServiceRuleDefaultInput,
+): string[] {
+  if (!isPlainObjectPayload(input)) return ["invalidPayload"];
+
+  const codes: string[] = [];
+  if (!VALID_SERVICE_SCOPES.has(input.scope as ServiceScope))
+    codes.push("invalidScope");
+  if (typeof input.category !== "string") codes.push("invalidCategory");
+  if (typeof input.name !== "string") codes.push("invalidRuleName");
+  return codes;
+}
+
+/**
+ * Update carries no `scope`/`category` (`ServiceRuleDefaultUpdateInput` omits
+ * them — it targets an existing row by id) so only the object check and
+ * `name`'s runtime type apply; `updateServiceRuleDefault` calls
+ * `input.name.trim()`, which would otherwise throw the same raw `TypeError`
+ * create's guard exists to prevent.
+ */
+function validateServiceRuleDefaultUpdateInput(
+  input: ServiceRuleDefaultUpdateInput,
+): string[] {
+  if (!isPlainObjectPayload(input)) return ["invalidPayload"];
+  if (typeof input.name !== "string") return ["invalidRuleName"];
+  return [];
+}
+
+/**
+ * Delete's payload IS the id (no wrapping object) — it has no fields to
+ * validate beyond its own type, so it gets its own minimal check rather than
+ * being forced through the object-shaped validators above.
+ */
+function validateServiceRuleDefaultId(id: string): string[] {
+  return typeof id === "string" ? [] : ["invalidPayload"];
+}
+
+export async function createServiceRuleDefaultAction(
+  input: ServiceRuleDefaultInput,
+): Promise<ActionResult<{ default: ServiceRuleDefaultRow }>> {
+  const codes = validateServiceRuleDefaultInput(input);
+  if (codes.length > 0) return { ok: false, codes };
+  return withActionContext("settings-service-defaults", async (userId) => {
+    const created = await createServiceRuleDefault(userId, input);
+    revalidateServiceDefaultsPath();
+    return { ok: true, data: { default: created } };
+  });
+}
+
+export async function updateServiceRuleDefaultAction(
+  id: string,
+  input: ServiceRuleDefaultUpdateInput,
+): Promise<ActionResult<{ default: ServiceRuleDefaultRow }>> {
+  const codes = validateServiceRuleDefaultUpdateInput(input);
+  if (codes.length > 0) return { ok: false, codes };
+  return withActionContext("settings-service-defaults", async (userId) => {
+    const updated = await updateServiceRuleDefault(userId, id, input);
+    revalidateServiceDefaultsPath();
+    return { ok: true, data: { default: updated } };
+  });
+}
+
+export async function deleteServiceRuleDefaultAction(
+  id: string,
+): Promise<ActionResult> {
+  const codes = validateServiceRuleDefaultId(id);
+  if (codes.length > 0) return { ok: false, codes };
+  return withActionContext("settings-service-defaults", async (userId) => {
+    await deleteServiceRuleDefault(userId, id);
+    revalidateServiceDefaultsPath();
+    return { ok: true };
+  });
+}
diff --git a/app/(app)/settings/service/default-rule-form.tsx b/app/(app)/settings/service/default-rule-form.tsx
new file mode 100644
index 00000000..6deca8a4
--- /dev/null
+++ b/app/(app)/settings/service/default-rule-form.tsx
@@ -0,0 +1,287 @@
+"use client";
+
+import { type FormEvent, useId, useState, useTransition } from "react";
+import { Button } from "@/components/ui/button";
+import { Callout } from "@/components/ui/feedback";
+import { Field } from "@/components/ui/field";
+import { Input } from "@/components/ui/input";
+import type { ActionResult } from "@/src/domain/action-result";
+import { MIN_THRESHOLD } from "@/src/domain/service-intervals/constants";
+import {
+  type ServiceRuleInput,
+  validateServiceRuleSet,
+} from "@/src/domain/service-intervals/validate";
+import { firstMessage } from "@/src/domain/validation-messages";
+import type { CategoryDefaultRule } from "./types";
+
+/**
+ * The rule-name-plus-three-thresholds shape shared by every rule-editing
+ * surface in the service-intervals feature (U7/U8): `ServiceRuleForm` below
+ * is the ONE add/edit form for a name-plus-three-thresholds rule, used for
+ * editing a category default (`CategorySectionCard` in
+ * `service-defaults-form.tsx`) AND for a firearm/accessory's own item rules
+ * (override an inherited default, or add an item-only rule — see
+ * `service-rules-panel.tsx` in `app/(app)/firearms/`). Arming a brand-new
+ * accessory category (`AddAccessoryCategoryPanel`, also in
+ * `service-defaults-form.tsx`) has an extra category field ahead of the rule
+ * fields and a different single-button footer, so it composes `ThresholdInputs`
+ * and this file's helpers directly rather than wrapping `ServiceRuleForm`.
+ *
+ * The two prior near-duplicate components (a settings-only `DefaultRuleForm`
+ * taking `siblings: CategoryDefaultRule[]`, and a firearms-only
+ * `ServiceRuleForm` taking `siblingNames: string[]` plus a `nameLocked` flag)
+ * collapsed into this single component once `siblingNames: string[]` proved
+ * sufficient for both: `validateServiceRuleSet`'s duplicate-name check only
+ * reads `name` off sibling entries, and marking every one `suppressed: true`
+ * short-circuits its `missingThreshold`/`thresholdTooLow` checks for a
+ * fabricated sibling exactly the way an already-valid real default's
+ * thresholds would anyway (they can never fail those checks — they were
+ * validated when created).
+ */
+
+export interface RuleFieldValues {
+  name: string;
+  days: string;
+  sessions: string;
+  rounds: string;
+}
+
+export const EMPTY_RULE_VALUES: RuleFieldValues = {
+  name: "",
+  days: "",
+  sessions: "",
+  rounds: "",
+};
+
+export const NAME_CODES = ["emptyName", "duplicateName"];
+export const THRESHOLD_CODES = ["thresholdTooLow", "missingThreshold"];
+
+export function toRuleValues(rule: CategoryDefaultRule): RuleFieldValues {
+  return {
+    name: rule.name,
+    days: rule.intervalDays?.toString() ?? "",
+    sessions: rule.intervalSessions?.toString() ?? "",
+    rounds: rule.intervalRounds?.toString() ?? "",
+  };
+}
+
+export function toRuleInput(values: RuleFieldValues): ServiceRuleInput {
+  return {
+    name: values.name,
+    intervalDays: values.days === "" ? null : Number(values.days),
+    intervalSessions: values.sessions === "" ? null : Number(values.sessions),
+    intervalRounds: values.rounds === "" ? null : Number(values.rounds),
+  };
+}
+
+interface ThresholdInputsProps {
+  values: RuleFieldValues;
+  onChange: (axis: "days" | "sessions" | "rounds", value: string) => void;
+  ids: { days: string; sessions: string; rounds: string };
+  error?: string;
+  errorId: string;
+  invalid: boolean;
+}
+
+/** The three threshold fields shared by every rule form (add or edit). */
+export function ThresholdInputs({
+  values,
+  onChange,
+  ids,
+  error,
+  errorId,
+  invalid,
+}: ThresholdInputsProps) {
+  return (
+    <div className="flex flex-col gap-1.5">
+      <div className="grid grid-cols-1 gap-3 sm:grid-cols-3">
+        <Field label="Days" controlId={ids.days}>
+          <Input
+            id={ids.days}
+            type="number"
+            inputMode="numeric"
+            min={MIN_THRESHOLD}
+            step={1}
+            value={values.days}
+            onChange={(e) => onChange("days", e.target.value)}
+            aria-invalid={invalid}
+            aria-describedby={invalid ? errorId : undefined}
+          />
+        </Field>
+        <Field label="Range sessions" controlId={ids.sessions}>
+          <Input
+            id={ids.sessions}
+            type="number"
+            inputMode="numeric"
+            min={MIN_THRESHOLD}
+            step={1}
+            value={values.sessions}
+            onChange={(e) => onChange("sessions", e.target.value)}
+            aria-invalid={invalid}
+            aria-describedby={invalid ? errorId : undefined}
+          />
+        </Field>
+        <Field label="Rounds fired" controlId={ids.rounds}>
+          <Input
+            id={ids.rounds}
+            type="number"
+            inputMode="numeric"
+            min={MIN_THRESHOLD}
+            step={1}
+            value={values.rounds}
+            onChange={(e) => onChange("rounds", e.target.value)}
+            aria-invalid={invalid}
+            aria-describedby={invalid ? errorId : undefined}
+          />
+        </Field>
+      </div>
+      <p
+        id={errorId}
+        role={error ? "alert" : undefined}
+        className={
+          error
+            ? "text-xs font-medium text-destructive"
+            : "text-xs text-muted-foreground"
+        }
+      >
+        {error ?? "Set at least one threshold — whichever comes first is due."}
+      </p>
+    </div>
+  );
+}
+
+export interface ServiceRuleFormProps {
+  initial?: RuleFieldValues;
+  /**
+   * Every OTHER rule name already in this set (active + suppressed),
+   * excluding the one being edited — a category's sibling defaults, or an
+   * item's sibling rules. `validateServiceRuleSet` only reads `name` off
+   * these (see this file's top comment), so callers pass names, not full
+   * rows.
+   */
+  siblingNames: string[];
+  /**
+   * Locks the name field — set when overriding a default-backed item rule,
+   * whose name must stay the default's name to keep resolving as that same
+   * rule. Never set for a category default (its name IS the rule's identity)
+   * or an item-only rule (nothing to keep in sync with).
+   */
+  nameLocked?: boolean;
+  submitLabel: string;
+  pendingLabel: string;
+  onCancel: () => void;
+  onSubmit: (input: ServiceRuleInput) => Promise<ActionResult<unknown>>;
+  onSaved: () => void;
+}
+
+/**
+ * Add/edit form for one name-plus-three-thresholds rule: a category default,
+ * or a firearm/accessory's own item rule (override or item-only). See this
+ * file's top comment for how the two prior near-duplicate components merged
+ * into this one.
+ */
+export function ServiceRuleForm({
+  initial,
+  siblingNames,
+  nameLocked = false,
+  submitLabel,
+  pendingLabel,
+  onCancel,
+  onSubmit,
+  onSaved,
+}: ServiceRuleFormProps) {
+  const [values, setValues] = useState<RuleFieldValues>(
+    initial ?? EMPTY_RULE_VALUES,
+  );
+  const [codes, setCodes] = useState<string[]>([]);
+  const [serverError, setServerError] = useState<string | null>(null);
+  const [pending, startTransition] = useTransition();
+  const nameId = useId();
+  const thresholdsErrorId = useId();
+  const ids = { days: useId(), sessions: useId(), rounds: useId() };
+
+  function set(key: keyof RuleFieldValues, value: string) {
+    setValues((v) => ({ ...v, [key]: value }));
+  }
+
+  function submit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    const input = toRuleInput(values);
+    const siblingInputs: ServiceRuleInput[] = siblingNames.map((name) => ({
+      name,
+      suppressed: true,
+    }));
+    const found = validateServiceRuleSet([...siblingInputs, input]);
+    setCodes(found);
+    setServerError(null);
+    if (found.length > 0) {
+      const nameInvalid = found.some((c) => NAME_CODES.includes(c));
+      document.getElementById(nameInvalid ? nameId : ids.days)?.focus();
+      return;
+    }
+    startTransition(async () => {
+      // Trimmed here (not just left to the server) because the firearms
+      // item-rule actions (`overrideServiceRuleAction`,
+      // `addItemOnlyRuleAction`) resolve an existing rule by an exact
+      // `row.name === name` string match BEFORE any server-side trim runs
+      // (`findItemRuleByName` in `service-actions.ts`) — an untrimmed name
+      // with incidental whitespace would miss that match and misfire a
+      // create instead of an update. A no-op for the category-default path,
+      // whose actions look up the target row by id and trim independently.
+      const result = await onSubmit({ ...input, name: input.name.trim() });
+      if (result.ok) {
+        onSaved();
+      } else if (result.codes) {
+        setCodes(result.codes);
+      } else {
+        setServerError(result.error ?? "Could not save.");
+      }
+    });
+  }
+
+  return (
+    <form
+      onSubmit={submit}
+      className="flex flex-col gap-3 rounded-md border border-input p-3"
+      noValidate
+    >
+      {serverError ? <Callout tone="destructive">{serverError}</Callout> : null}
+      <Field
+        label="Rule name"
+        controlId={nameId}
+        required
+        error={firstMessage(codes, NAME_CODES)}
+      >
+        <Input
+          id={nameId}
+          value={values.name}
+          onChange={(e) => set("name", e.target.value)}
+          aria-invalid={NAME_CODES.some((c) => codes.includes(c))}
+          readOnly={nameLocked}
+        />
+      </Field>
+      <ThresholdInputs
+        values={values}
+        onChange={set}
+        ids={ids}
+        error={firstMessage(codes, THRESHOLD_CODES)}
+        errorId={thresholdsErrorId}
+        invalid={THRESHOLD_CODES.some((c) => codes.includes(c))}
+      />
+      <div className="flex items-center gap-2">
+        <Button type="submit" size="sm" disabled={pending}>
+          {pending ? pendingLabel : submitLabel}
+        </Button>
+        <Button
+          type="button"
+          variant="ghost"
+          size="sm"
+          onClick={onCancel}
+          disabled={pending}
+        >
+          Cancel
+        </Button>
+      </div>
+    </form>
+  );
+}
diff --git a/app/(app)/settings/service/page.tsx b/app/(app)/settings/service/page.tsx
new file mode 100644
index 00000000..2c5a6303
--- /dev/null
+++ b/app/(app)/settings/service/page.tsx
@@ -0,0 +1,115 @@
+import { redirect } from "next/navigation";
+import { PageHeader } from "@/components/ui/surface";
+import { getCurrentUser } from "@/src/auth/session";
+import {
+  FIREARM_TYPES,
+  firearmTypeLabel,
+  isRealFirearmType,
+} from "@/src/domain/firearms/constants";
+import {
+  countItemsByCategory,
+  listConfiguredCategories,
+  listOwnerAccessoryCategories,
+  listServiceRuleDefaultsByCategory,
+  type ServiceRuleDefaultRow,
+} from "@/src/domain/service-intervals/rules-service";
+import { ServiceDefaultsForm } from "./service-defaults-form";
+import type { CategorySection } from "./types";
+
+/**
+ * Service-defaults settings surface (U7). Owner-only, collection-wide
+ * configuration: one default rule set per firearm type (fixed list,
+ * `FIREARM_TYPES`) and per accessory category (free text, KD10) — arming a
+ * category here reaches every item in it live (R4), with no item visited.
+ *
+ * Firearm categories are always shown, whether or not the owner has a
+ * firearm of that type yet — the type list is fixed, so there's nothing to
+ * derive. Accessory categories merge the owner's real distinct categories
+ * (`listOwnerAccessoryCategories`, KTD8) with any category already carrying a
+ * default (`listConfiguredCategories`) so a category armed ahead of an
+ * accessory existing — or whose only accessory was since deleted — still has
+ * a section here rather than becoming invisible.
+ */
+
+/**
+ * Builds each scope's sections from the already-batch-loaded defaults-by-
+ * category and count-by-category maps (one query each, regardless of how
+ * many categories exist) rather than a query pair per category.
+ */
+function loadSections(
+  categories: { category: string; label: string }[],
+  defaultsByCategory: Map<string, ServiceRuleDefaultRow[]>,
+  countByCategory: Map<string, number>,
+): CategorySection[] {
+  return categories.map(({ category, label }) => ({
+    category,
+    label,
+    itemCount: countByCategory.get(category) ?? 0,
+    defaults: (defaultsByCategory.get(category) ?? []).map((d) => ({
+      id: d.id,
+      name: d.name,
+      intervalDays: d.intervalDays,
+      intervalSessions: d.intervalSessions,
+      intervalRounds: d.intervalRounds,
+    })),
+  }));
+}
+
+export default async function ServiceDefaultsPage() {
+  const user = await getCurrentUser();
+  if (!user) redirect("/login");
+
+  const firearmCategories = FIREARM_TYPES.filter(isRealFirearmType).map(
+    (type) => ({ category: type, label: firearmTypeLabel(type) }),
+  );
+
+  const [existingAccessoryCategories, configuredAccessoryCategories] =
+    await Promise.all([
+      listOwnerAccessoryCategories(user.id),
+      listConfiguredCategories(user.id, "accessory"),
+    ]);
+  const accessoryCategoryNames = [
+    ...new Set([
+      ...existingAccessoryCategories,
+      ...configuredAccessoryCategories,
+    ]),
+  ].sort((a, b) => a.localeCompare(b));
+  const accessoryCategories = accessoryCategoryNames.map((category) => ({
+    category,
+    label: category,
+  }));
+
+  // One grouped-by-category query per data source per scope (four total),
+  // instead of a defaults + count query pair for every individual category.
+  const [firearmDefaults, firearmCounts, accessoryDefaults, accessoryCounts] =
+    await Promise.all([
+      listServiceRuleDefaultsByCategory(user.id, "firearm"),
+      countItemsByCategory(user.id, "firearm"),
+      listServiceRuleDefaultsByCategory(user.id, "accessory"),
+      countItemsByCategory(user.id, "accessory"),
+    ]);
+  const firearmSections = loadSections(
+    firearmCategories,
+    firearmDefaults,
+    firearmCounts,
+  );
+  const accessorySections = loadSections(
+    accessoryCategories,
+    accessoryDefaults,
+    accessoryCounts,
+  );
+
+  return (
+    <div className="space-y-6">
+      <PageHeader
+        title="Service-interval defaults"
+        description="Set per-category service rules once — every item of that category inherits them live, without visiting any of them."
+      />
+      <ServiceDefaultsForm
+        firearmSections={firearmSections}
+        accessorySections={accessorySections}
+        existingAccessoryCategories={existingAccessoryCategories}
+      />
+    </div>
+  );
+}
diff --git a/app/(app)/settings/service/service-defaults-form.tsx b/app/(app)/settings/service/service-defaults-form.tsx
new file mode 100644
index 00000000..b0b60d00
--- /dev/null
+++ b/app/(app)/settings/service/service-defaults-form.tsx
@@ -0,0 +1,445 @@
+"use client";
+
+import { useRouter } from "next/navigation";
+import { type FormEvent, useId, useState, useTransition } from "react";
+import { Button } from "@/components/ui/button";
+import { ConfirmDialog } from "@/components/ui/confirm-dialog";
+import { Callout, EmptyState } from "@/components/ui/feedback";
+import { Field } from "@/components/ui/field";
+import { Input } from "@/components/ui/input";
+import { Card } from "@/components/ui/surface";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/ui/table";
+import { useToast } from "@/components/ui/toast";
+import { validateServiceRuleSet } from "@/src/domain/service-intervals/validate";
+import { firstMessage } from "@/src/domain/validation-messages";
+import {
+  createServiceRuleDefaultAction,
+  deleteServiceRuleDefaultAction,
+  updateServiceRuleDefaultAction,
+} from "./actions";
+import {
+  EMPTY_RULE_VALUES,
+  NAME_CODES,
+  type RuleFieldValues,
+  ServiceRuleForm,
+  THRESHOLD_CODES,
+  ThresholdInputs,
+  toRuleInput,
+  toRuleValues,
+} from "./default-rule-form";
+import type { CategoryDefaultRule, CategorySection } from "./types";
+
+/**
+ * Client form for the service-defaults settings surface (U7). Category data
+ * (which categories exist, their existing default rules, and how many items
+ * each reaches) comes entirely from server-rendered props — this component
+ * holds only ephemeral UI state (which row is open for edit, which default is
+ * pending delete confirmation) and calls `router.refresh()` after every
+ * mutation so the next render carries fresh server data, rather than cloning
+ * the props into local state and letting it drift stale (React Compiler:
+ * pass reactive slices through, don't shadow them).
+ */
+
+export type { CategoryDefaultRule, CategorySection };
+
+interface ServiceDefaultsFormProps {
+  firearmSections: CategorySection[];
+  accessorySections: CategorySection[];
+  /** Owner's real accessory categories — suggestions for the new-category field. */
+  existingAccessoryCategories: string[];
+}
+
+function formatThreshold(value: number | null, unit: string): string {
+  return value === null ? "—" : `${value} ${unit}`;
+}
+
+type OpenForm = { kind: "add" } | { kind: "edit"; id: string } | null;
+
+interface CategorySectionCardProps {
+  section: CategorySection;
+  scope: "firearm" | "accessory";
+  itemNounSingular: string;
+  itemNounPlural: string;
+  onRequestDelete: (rule: CategoryDefaultRule, categoryLabel: string) => void;
+}
+
+function CategorySectionCard({
+  section,
+  scope,
+  itemNounSingular,
+  itemNounPlural,
+  onRequestDelete,
+}: CategorySectionCardProps) {
+  const router = useRouter();
+  const { toast } = useToast();
+  const [openForm, setOpenForm] = useState<OpenForm>(null);
+  const noun = section.itemCount === 1 ? itemNounSingular : itemNounPlural;
+
+  function afterSaved(message: string) {
+    setOpenForm(null);
+    toast({ message });
+    router.refresh();
+  }
+
+  return (
+    <Card role="region" aria-label={section.label}>
+      <div className="mb-3 flex items-start justify-between gap-3">
+        <div>
+          <h3 className="text-sm font-semibold text-foreground">
+            {section.label}
+          </h3>
+          <p className="text-xs text-muted-foreground">
+            Reaches {section.itemCount} {noun} in your collection
+          </p>
+        </div>
+        {openForm === null ? (
+          <Button
+            size="sm"
+            variant="outline"
+            onClick={() => setOpenForm({ kind: "add" })}
+          >
+            Add rule
+          </Button>
+        ) : null}
+      </div>
+
+      {section.defaults.length === 0 && openForm === null ? (
+        <EmptyState
+          title="No default rules yet"
+          description="Add a rule so every item in this category resolves it live."
+        />
+      ) : null}
+
+      {section.defaults.length > 0 ? (
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHead>Rule</TableHead>
+              <TableHead>Days</TableHead>
+              <TableHead>Sessions</TableHead>
+              <TableHead>Rounds</TableHead>
+              <TableHead>
+                <span className="sr-only">Actions</span>
+              </TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {section.defaults.map((rule) =>
+              openForm?.kind === "edit" && openForm.id === rule.id ? (
+                <TableRow key={rule.id}>
+                  <TableCell colSpan={5}>
+                    <ServiceRuleForm
+                      initial={toRuleValues(rule)}
+                      siblingNames={section.defaults
+                        .filter((d) => d.id !== rule.id)
+                        .map((d) => d.name)}
+                      submitLabel="Save changes"
+                      pendingLabel="Saving…"
+                      onCancel={() => setOpenForm(null)}
+                      onSubmit={(input) =>
+                        updateServiceRuleDefaultAction(rule.id, input)
+                      }
+                      onSaved={() => afterSaved(`${rule.name} updated`)}
+                    />
+                  </TableCell>
+                </TableRow>
+              ) : (
+                <TableRow key={rule.id}>
+                  <TableCell className="font-medium text-foreground">
+                    {rule.name}
+                  </TableCell>
+                  <TableCell>
+                    {formatThreshold(rule.intervalDays, "days")}
+                  </TableCell>
+                  <TableCell>
+                    {formatThreshold(rule.intervalSessions, "sessions")}
+                  </TableCell>
+                  <TableCell>
+                    {formatThreshold(rule.intervalRounds, "rounds")}
+                  </TableCell>
+                  <TableCell>
+                    <div className="flex justify-end gap-1">
+                      <Button
+                        variant="ghost"
+                        size="sm"
+                        onClick={() =>
+                          setOpenForm({ kind: "edit", id: rule.id })
+                        }
+                      >
+                        Edit
+                      </Button>
+                      <Button
+                        variant="destructive"
+                        size="sm"
+                        onClick={() => onRequestDelete(rule, section.label)}
+                      >
+                        Delete
+                      </Button>
+                    </div>
+                  </TableCell>
+                </TableRow>
+              ),
+            )}
+          </TableBody>
+        </Table>
+      ) : null}
+
+      {openForm?.kind === "add" ? (
+        <div className="mt-3">
+          <ServiceRuleForm
+            siblingNames={section.defaults.map((d) => d.name)}
+            submitLabel="Add rule"
+            pendingLabel="Adding…"
+            onCancel={() => setOpenForm(null)}
+            onSubmit={(input) =>
+              createServiceRuleDefaultAction({
+                scope,
+                category: section.category,
+                ...input,
+              })
+            }
+            onSaved={() => afterSaved(`${section.label} rule added`)}
+          />
+        </div>
+      ) : null}
+    </Card>
+  );
+}
+
+interface AddAccessoryCategoryPanelProps {
+  existingAccessoryCategories: string[];
+}
+
+/**
+ * Arms a brand-new accessory category (KTD8) — free text, no live accessory
+ * required, so a category can be configured before the first item in it
+ * exists. Suggests the owner's real categories via a datalist so a near-typo
+ * ("Optics" vs "Optic") is caught before it silently strands a second,
+ * unrelated default set (KD10).
+ */
+function AddAccessoryCategoryPanel({
+  existingAccessoryCategories,
+}: AddAccessoryCategoryPanelProps) {
+  const router = useRouter();
+  const { toast } = useToast();
+  const [category, setCategory] = useState("");
+  const [values, setValues] = useState<RuleFieldValues>(EMPTY_RULE_VALUES);
+  const [categoryError, setCategoryError] = useState<string | null>(null);
+  const [codes, setCodes] = useState<string[]>([]);
+  const [serverError, setServerError] = useState<string | null>(null);
+  const [pending, startTransition] = useTransition();
+  const categoryId = useId();
+  const nameId = useId();
+  const thresholdsErrorId = useId();
+  const ids = { days: useId(), sessions: useId(), rounds: useId() };
+
+  function set(key: keyof RuleFieldValues, value: string) {
+    setValues((v) => ({ ...v, [key]: value }));
+  }
+
+  function submit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    const trimmedCategory = category.trim();
+    const input = toRuleInput(values);
+    const found = validateServiceRuleSet([input]);
+    setCodes(found);
+    setCategoryError(trimmedCategory === "" ? "Category is required" : null);
+    setServerError(null);
+    if (trimmedCategory === "" || found.length > 0) {
+      if (trimmedCategory === "") {
+        document.getElementById(categoryId)?.focus();
+      } else {
+        const nameInvalid = found.some((c) => NAME_CODES.includes(c));
+        document.getElementById(nameInvalid ? nameId : ids.days)?.focus();
+      }
+      return;
+    }
+    startTransition(async () => {
+      const result = await createServiceRuleDefaultAction({
+        scope: "accessory",
+        category: trimmedCategory,
+        ...input,
+      });
+      if (result.ok) {
+        toast({ message: `${trimmedCategory} armed`, detail: input.name });
+        setCategory("");
+        setValues(EMPTY_RULE_VALUES);
+        router.refresh();
+      } else if (result.codes) {
+        setCodes(result.codes);
+      } else {
+        setServerError(result.error ?? "Could not save.");
+      }
+    });
+  }
+
+  return (
+    <Card role="region" aria-label="Add a new accessory category">
+      <h3 className="mb-1 text-sm font-semibold text-foreground">
+        Add a new accessory category
+      </h3>
+      <p className="mb-3 text-xs text-muted-foreground">
+        Arm a category ahead of owning an accessory in it — a category with no
+        matching accessory yet still inherits nothing until one exists.
+      </p>
+      <datalist id="service-defaults-accessory-categories">
+        {existingAccessoryCategories.map((c) => (
+          <option key={c} value={c} />
+        ))}
+      </datalist>
+      <form onSubmit={submit} className="flex flex-col gap-3" noValidate>
+        {serverError ? (
+          <Callout tone="destructive">{serverError}</Callout>
+        ) : null}
+        <Field
+          label="Category"
+          controlId={categoryId}
+          required
+          error={categoryError ?? undefined}
+        >
+          <Input
+            id={categoryId}
+            list="service-defaults-accessory-categories"
+            value={category}
+            onChange={(e) => setCategory(e.target.value)}
+            aria-invalid={Boolean(categoryError)}
+          />
+        </Field>
+        <Field
+          label="Rule name"
+          controlId={nameId}
+          required
+          error={firstMessage(codes, NAME_CODES)}
+        >
+          <Input
+            id={nameId}
+            value={values.name}
+            onChange={(e) => set("name", e.target.value)}
+            aria-invalid={NAME_CODES.some((c) => codes.includes(c))}
+          />
+        </Field>
+        <ThresholdInputs
+          values={values}
+          onChange={set}
+          ids={ids}
+          error={firstMessage(codes, THRESHOLD_CODES)}
+          errorId={thresholdsErrorId}
+          invalid={THRESHOLD_CODES.some((c) => codes.includes(c))}
+        />
+        <div>
+          <Button type="submit" size="sm" disabled={pending}>
+            {pending ? "Adding…" : "Add category"}
+          </Button>
+        </div>
+      </form>
+    </Card>
+  );
+}
+
+interface DeleteTarget {
+  rule: CategoryDefaultRule;
+  categoryLabel: string;
+}
+
+export function ServiceDefaultsForm({
+  firearmSections,
+  accessorySections,
+  existingAccessoryCategories,
+}: ServiceDefaultsFormProps) {
+  const router = useRouter();
+  const { toast } = useToast();
+  const [target, setTarget] = useState<DeleteTarget | null>(null);
+  const [deleting, startDelete] = useTransition();
+
+  function confirmDelete() {
+    const current = target;
+    if (!current) return;
+    startDelete(async () => {
+      const result = await deleteServiceRuleDefaultAction(current.rule.id);
+      setTarget(null);
+      if (result.ok) {
+        toast({ message: `${current.rule.name} removed`, tone: "neutral" });
+        router.refresh();
+      } else {
+        toast({
+          message: result.error ?? "Could not delete.",
+          tone: "destructive",
+        });
+      }
+    });
+  }
+
+  return (
+    <div className="space-y-8">
+      <section className="space-y-4">
+        <h2 className="text-base font-semibold text-foreground">
+          Firearm categories
+        </h2>
+        <div className="grid gap-4 sm:grid-cols-2">
+          {firearmSections.map((section) => (
+            <CategorySectionCard
+              key={section.category}
+              section={section}
+              scope="firearm"
+              itemNounSingular="firearm"
+              itemNounPlural="firearms"
+              onRequestDelete={(rule, categoryLabel) =>
+                setTarget({ rule, categoryLabel })
+              }
+            />
+          ))}
+        </div>
+      </section>
+
+      <section className="space-y-4">
+        <h2 className="text-base font-semibold text-foreground">
+          Accessory categories
+        </h2>
+        {accessorySections.length > 0 ? (
+          <div className="grid gap-4 sm:grid-cols-2">
+            {accessorySections.map((section) => (
+              <CategorySectionCard
+                key={section.category}
+                section={section}
+                scope="accessory"
+                itemNounSingular="accessory"
+                itemNounPlural="accessories"
+                onRequestDelete={(rule, categoryLabel) =>
+                  setTarget({ rule, categoryLabel })
+                }
+              />
+            ))}
+          </div>
+        ) : (
+          <EmptyState
+            title="No accessory categories configured"
+            description="Add a category below to start tracking service on your accessories."
+          />
+        )}
+        <AddAccessoryCategoryPanel
+          existingAccessoryCategories={existingAccessoryCategories}
+        />
+      </section>
+
+      <ConfirmDialog
+        open={target !== null}
+        title={target ? `Delete the "${target.rule.name}" default?` : ""}
+        description={
+          target
+            ? `Every ${target.categoryLabel} item that has not overridden this rule will lose it immediately.`
+            : undefined
+        }
+        pending={deleting}
+        onConfirm={confirmDelete}
+        onCancel={() => setTarget(null)}
+      />
+    </div>
+  );
+}
diff --git a/app/(app)/settings/service/types.ts b/app/(app)/settings/service/types.ts
new file mode 100644
index 00000000..e5fd9acd
--- /dev/null
+++ b/app/(app)/settings/service/types.ts
@@ -0,0 +1,21 @@
+/**
+ * Shared shapes for the service-defaults settings surface (U7), split out so
+ * `default-rule-form.tsx` and `service-defaults-form.tsx` can both depend on
+ * them without importing from each other.
+ */
+
+export interface CategoryDefaultRule {
+  id: string;
+  name: string;
+  intervalDays: number | null;
+  intervalSessions: number | null;
+  intervalRounds: number | null;
+}
+
+export interface CategorySection {
+  category: string;
+  label: string;
+  /** Owner's items currently in this category (R4's live-inheritance reach). */
+  itemCount: number;
+  defaults: CategoryDefaultRule[];
+}
diff --git a/app/(app)/summary/__tests__/actions.test.ts b/app/(app)/summary/__tests__/actions.test.ts
new file mode 100644
index 00000000..cb8f1aef
--- /dev/null
+++ b/app/(app)/summary/__tests__/actions.test.ts
@@ -0,0 +1,141 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+import { NotFoundError } from "@/src/auth/errors";
+import { ValidationError } from "@/src/domain/errors";
+import * as eventsService from "@/src/domain/service-intervals/events-service";
+
+/**
+ * Server-action unit tests for `markServicedBulkAction` (R16, the `/summary`
+ * bulk mark-serviced surface). Mocks the session and spies on
+ * `logServiceEventsBulk` (mirroring `firearms/__tests__/service-actions.test.ts`'s
+ * `spyOn` approach) rather than hitting the DB — this only exercises the
+ * `"use server"` action boundary: auth gating, forwarding, and `ActionResult`
+ * mapping. NOT mocked here: `@/src/db/client` — `app/(app)/settings/__tests__/actions.test.ts`
+ * already globally stubs that module with `mock.module`, and since `bun test app`
+ * runs every file in one process, that stub outlives its own file and would
+ * silently break a real-DB test in this file too (confirmed by direct repro:
+ * `db.insert is not a function`). The owner-only/edit-grantee authorization
+ * split itself is a real DB-dependent property of `logServiceEventsBulk`, so
+ * it's covered where it belongs — `src/domain/service-intervals/__tests__/events-service.test.ts`,
+ * which owns real (Testcontainers) DB coverage for this domain function,
+ * including its bulk path's owner/edit-grantee/view-grantee/accessory-owner
+ * cases. This file only proves the action forwards the resolved actor id and
+ * input to that already-tested function, and maps its outcomes without
+ * leaking internals.
+ */
+
+let currentUserId: string | null = null;
+mock.module("@/src/auth/session", () => ({
+  getCurrentUser: async () => (currentUserId ? { id: currentUserId } : null),
+}));
+
+let revalidateCalls: string[] = [];
+mock.module("next/cache", () => ({
+  revalidatePath: (path: string) => {
+    revalidateCalls.push(path);
+  },
+}));
+
+const { markServicedBulkAction } = await import("../actions");
+
+describe("markServicedBulkAction", () => {
+  let logServiceEventsBulkSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    currentUserId = null;
+    revalidateCalls = [];
+    logServiceEventsBulkSpy = spyOn(
+      eventsService,
+      "logServiceEventsBulk",
+    ).mockResolvedValue([
+      { id: "event-1", ruleName: "Cleaning" },
+    ] as unknown as eventsService.ServiceEventRow[]);
+  });
+
+  afterEach(() => {
+    logServiceEventsBulkSpy.mockRestore();
+  });
+
+  test("rejects an unauthenticated caller without touching the service", async () => {
+    currentUserId = null;
+
+    const result = await markServicedBulkAction(
+      [{ parentType: "firearm", parentId: "fa-1", ruleName: "Cleaning" }],
+      "2026-04-01",
+    );
+
+    expect(result.ok).toBe(false);
+    expect(logServiceEventsBulkSpy).not.toHaveBeenCalled();
+  });
+
+  test("happy path across several items: forwards the resolved actor, items, date, and notes, and revalidates every affected path", async () => {
+    currentUserId = "user-1";
+    const items = [
+      {
+        parentType: "firearm" as const,
+        parentId: "fa-1",
+        ruleName: "Cleaning",
+      },
+      {
+        parentType: "firearm" as const,
+        parentId: "fa-2",
+        ruleName: "Cleaning",
+      },
+      { parentType: "accessory" as const, parentId: "acc-1", ruleName: "Lens" },
+    ];
+
+    const result = await markServicedBulkAction(
+      items,
+      "2026-04-01",
+      "Spring clean",
+    );
+
+    expect(result.ok).toBe(true);
+    expect(logServiceEventsBulkSpy).toHaveBeenCalledWith("user-1", {
+      items,
+      servicedOn: "2026-04-01",
+      notes: "Spring clean",
+    });
+    expect(revalidateCalls).toContain("/summary");
+    expect(revalidateCalls).toContain("/firearms");
+    expect(revalidateCalls).toContain("/accessories");
+  });
+
+  test("the whole-batch rejection when one item is unauthorized maps to a non-leaking ActionResult and revalidates nothing", async () => {
+    currentUserId = "user-1";
+    logServiceEventsBulkSpy.mockImplementation(() => {
+      throw new NotFoundError();
+    });
+
+    const result = await markServicedBulkAction(
+      [{ parentType: "firearm", parentId: "fa-1", ruleName: "Cleaning" }],
+      "2026-04-01",
+    );
+
+    expect(result.ok).toBe(false);
+    expect(revalidateCalls).toEqual([]);
+  });
+
+  test("a future servicedOn maps a thrown ValidationError to a failed ActionResult with codes", async () => {
+    currentUserId = "user-1";
+    logServiceEventsBulkSpy.mockImplementation(() => {
+      throw new ValidationError(["servicedOnInFuture"]);
+    });
+
+    const result = await markServicedBulkAction(
+      [{ parentType: "firearm", parentId: "fa-1", ruleName: "Cleaning" }],
+      "2099-01-01",
+    );
+
+    expect(result.ok).toBe(false);
+    expect(result.ok === false && result.codes).toEqual(["servicedOnInFuture"]);
+    expect(revalidateCalls).toEqual([]);
+  });
+});
diff --git a/app/(app)/summary/actions.ts b/app/(app)/summary/actions.ts
new file mode 100644
index 00000000..4a313fd1
--- /dev/null
+++ b/app/(app)/summary/actions.ts
@@ -0,0 +1,43 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import type { ActionResult } from "@/src/domain/action-result";
+import {
+  type BulkServiceItem,
+  logServiceEventsBulk,
+  type ServiceEventRow,
+} from "@/src/domain/service-intervals/events-service";
+import { withActionContext } from "@/src/lib/logging/entry-context";
+
+/**
+ * Server action for the `/summary` bulk mark-serviced control (R16) — the
+ * surface that closes the day-one backlog gap KD6 creates: an owner with
+ * many due items can mark a selection of item-and-rule pairs serviced as of
+ * one date in a single action, instead of visiting each item.
+ *
+ * This is a thin wrapper: EVERY authorization, validation, and transaction
+ * decision belongs to `logServiceEventsBulk` (`events-service.ts`) — the
+ * same domain function the plan requires (R16, KTD3) — never reimplemented,
+ * bypassed, or weakened here. `actorId` is always the session-resolved user
+ * from `withActionContext`, never client-supplied.
+ */
+export async function markServicedBulkAction(
+  items: BulkServiceItem[],
+  servicedOn: string,
+  notes?: string,
+): Promise<ActionResult<{ events: ServiceEventRow[] }>> {
+  return withActionContext("service-bulk-log-events", async (userId) => {
+    const events = await logServiceEventsBulk(userId, {
+      items,
+      servicedOn,
+      notes,
+    });
+    // Revalidate every surface the bulk write can change: the roll-up itself,
+    // and the firearm/accessory list markers (R20) for any item that just
+    // cleared its only due rule.
+    revalidatePath("/summary");
+    revalidatePath("/firearms");
+    revalidatePath("/accessories");
+    return { ok: true, data: { events } };
+  });
+}
diff --git a/app/(app)/summary/page.tsx b/app/(app)/summary/page.tsx
index e96a9843..ef02c1a7 100644
--- a/app/(app)/summary/page.tsx
+++ b/app/(app)/summary/page.tsx
@@ -2,13 +2,51 @@ import { redirect } from "next/navigation";
 import { EmptyState } from "@/components/ui/feedback";
 import { PageHeader, Stat } from "@/components/ui/surface";
 import { getCurrentUser } from "@/src/auth/session";
+import { visibleFirearmPermissions } from "@/src/auth/visibility";
+import { db } from "@/src/db/client";
+import { accessoryDisplayName } from "@/src/domain/accessories/display";
+import { listAccessories } from "@/src/domain/accessories/service";
+import { firearmDisplayName } from "@/src/domain/firearms/display";
+import { listFirearms } from "@/src/domain/firearms/service";
+import { buildServiceBacklog } from "@/src/domain/service-intervals/backlog";
+import { listDueForVisibleCollection } from "@/src/domain/service-intervals/due-service";
 import { inventorySummary } from "@/src/domain/summary/summary";
 import { SummaryTables } from "./summary-tables";
 
 export default async function SummaryPage() {
   const user = await getCurrentUser();
   if (!user) redirect("/login");
-  const summary = await inventorySummary(user.id);
+
+  // Loaded once and reused for the roll-up counts AND the bulk mark-serviced
+  // control's backlog (R16) — `inventorySummary` would otherwise re-run
+  // `listDueForVisibleCollection`'s own batched pipeline a second time
+  // (KTD4), mirroring how `firearms/page.tsx` already reuses these loads.
+  const [firearms, accessories, firearmPermissions] = await Promise.all([
+    listFirearms(user.id),
+    listAccessories(user.id),
+    visibleFirearmPermissions(db, user.id),
+  ]);
+  const dueEntries = await listDueForVisibleCollection(
+    user.id,
+    undefined,
+    firearms,
+  );
+  const summary = await inventorySummary(user.id, dueEntries, firearms);
+  // The bulk mark-serviced checklist is a WRITE surface: a firearm
+  // view-grantee can see the owner's due state in the roll-up above (that's
+  // legitimate, unchanged), but `logServiceEventsBulk` never lets them log
+  // service (KTD3), so they must never be offered a checkbox for it.
+  const actionableFirearmIds = new Set(
+    [...firearmPermissions.entries()]
+      .filter(([, perm]) => perm === "owner" || perm === "edit")
+      .map(([id]) => id),
+  );
+  const serviceBacklog = buildServiceBacklog(
+    dueEntries,
+    new Map(firearms.map((f) => [f.id, firearmDisplayName(f)])),
+    new Map(accessories.map((a) => [a.id, accessoryDisplayName(a)])),
+    actionableFirearmIds,
+  );
 
   return (
     <div className="space-y-6">
@@ -19,7 +57,8 @@ export default async function SummaryPage() {
 
       {summary.totalMagazines === 0 &&
       summary.firearmCounts.length === 0 &&
-      summary.totalAmmoLots === 0 ? (
+      summary.totalAmmoLots === 0 &&
+      summary.itemsDue === 0 ? (
         <EmptyState
           title="Nothing to summarize yet"
           description="Add firearms, magazines, or ammo to see counts by caliber, by firearm, and low-stock roll-ups."
@@ -42,6 +81,9 @@ export default async function SummaryPage() {
             byCaliber={summary.byCaliber}
             firearmCounts={summary.firearmCounts}
             caliberCoverage={summary.caliberCoverage}
+            itemsDue={summary.itemsDue}
+            rulesDue={summary.rulesDue}
+            serviceBacklog={serviceBacklog}
           />
         </>
       )}
diff --git a/app/(app)/summary/service-backlog-control.tsx b/app/(app)/summary/service-backlog-control.tsx
new file mode 100644
index 00000000..44aea642
--- /dev/null
+++ b/app/(app)/summary/service-backlog-control.tsx
@@ -0,0 +1,217 @@
+"use client";
+
+import { useRouter } from "next/navigation";
+import { type FormEvent, useId, useMemo, useState, useTransition } from "react";
+import { Button } from "@/components/ui/button";
+import { Callout } from "@/components/ui/feedback";
+import { Field } from "@/components/ui/field";
+import { Input, Textarea } from "@/components/ui/input";
+import { Card } from "@/components/ui/surface";
+import { useToast } from "@/components/ui/toast";
+import type { BacklogRow } from "@/src/domain/service-intervals/backlog";
+import type { BulkServiceItem } from "@/src/domain/service-intervals/events-service";
+import { validateServicedOn } from "@/src/domain/service-intervals/validate-event";
+import { firstMessage, messageForCode } from "@/src/domain/validation-messages";
+import { todayIso } from "@/src/lib/dates";
+import { markServicedBulkAction } from "./actions";
+
+/**
+ * The `/summary` bulk mark-serviced control (R16) — the surface this
+ * requirement was missing entirely: `logServiceEventsBulk` existed and was
+ * tested, but nothing in the app called it, so an owner with many due items
+ * still had to visit each one. This closes that gap from the one place the
+ * owner already sees the whole backlog (KD8's roll-up).
+ *
+ * R21 (advisory only): nothing here blocks, gates, or confirms — no
+ * `ConfirmDialog`. Safe-by-default (no bulk write is undoable): every
+ * checkbox starts UNCHECKED, "Select all" is an explicit opt-in click, and
+ * the submit button stays disabled until at least one row is checked. The
+ * checklist itself is what "shows the owner exactly what will be marked
+ * before they commit" — every due row is visible, checked or not, and only
+ * the checked ones are sent.
+ *
+ * Renders nothing when the backlog is empty — the roll-up text above
+ * ("0 items due…") already says so; an empty control here would be noise.
+ */
+
+const DATE_CODES = [
+  "emptyServicedOn",
+  "invalidServicedOn",
+  "servicedOnInFuture",
+];
+
+export interface ServiceBacklogControlProps {
+  backlog: BacklogRow[];
+}
+
+function rowKey(row: BacklogRow): string {
+  return `${row.parentType}::${row.parentId}::${row.ruleName}`;
+}
+
+export function ServiceBacklogControl({ backlog }: ServiceBacklogControlProps) {
+  const router = useRouter();
+  const { toast } = useToast();
+  const [selected, setSelected] = useState<Set<string>>(new Set());
+  const [servicedOn, setServicedOn] = useState(todayIso());
+  const [notes, setNotes] = useState("");
+  const [codes, setCodes] = useState<string[]>([]);
+  const [serverError, setServerError] = useState<string | null>(null);
+  const [pending, startTransition] = useTransition();
+  const dateId = useId();
+  const notesId = useId();
+  const selectAllId = useId();
+  const rowIdPrefix = useId();
+
+  const allKeys = useMemo(() => backlog.map(rowKey), [backlog]);
+  const allSelected = allKeys.length > 0 && selected.size === allKeys.length;
+
+  if (backlog.length === 0) return null;
+
+  function toggleRow(key: string) {
+    setSelected((current) => {
+      const next = new Set(current);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      return next;
+    });
+  }
+
+  function toggleAll() {
+    setSelected(allSelected ? new Set() : new Set(allKeys));
+  }
+
+  function submit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    const found = validateServicedOn(servicedOn);
+    setCodes(found);
+    setServerError(null);
+    if (found.length > 0) {
+      document.getElementById(dateId)?.focus();
+      return;
+    }
+    const items: BulkServiceItem[] = backlog
+      .filter((row) => selected.has(rowKey(row)))
+      .map((row) => ({
+        parentType: row.parentType,
+        parentId: row.parentId,
+        ruleName: row.ruleName,
+      }));
+    if (items.length === 0) return;
+
+    startTransition(async () => {
+      const result = await markServicedBulkAction(items, servicedOn, notes);
+      if (result.ok) {
+        toast({
+          message: `Marked ${items.length} ${items.length === 1 ? "rule" : "rules"} serviced`,
+        });
+        setSelected(new Set());
+        setNotes("");
+        router.refresh();
+      } else if (result.codes) {
+        setCodes(result.codes);
+        const nonDateCode = result.codes.find(
+          (code) => !DATE_CODES.includes(code),
+        );
+        if (nonDateCode) {
+          setServerError(messageForCode(nonDateCode));
+        }
+      } else {
+        setServerError(result.error ?? "Could not mark service.");
+      }
+    });
+  }
+
+  return (
+    <Card role="region" aria-label="Mark service due">
+      <h2 className="mb-4 text-sm font-semibold text-foreground">
+        Mark serviced
+      </h2>
+      <form onSubmit={submit} className="flex flex-col gap-4" noValidate>
+        {serverError ? (
+          <Callout tone="destructive">{serverError}</Callout>
+        ) : null}
+
+        <div className="flex items-center justify-between gap-3 border-b border-border pb-2">
+          <label
+            htmlFor={selectAllId}
+            className="flex items-center gap-2 text-sm font-medium text-foreground"
+          >
+            <input
+              id={selectAllId}
+              type="checkbox"
+              checked={allSelected}
+              onChange={toggleAll}
+              className="size-4 rounded border-input accent-primary"
+            />
+            Select all
+          </label>
+          <span className="text-xs text-muted-foreground" aria-live="polite">
+            {selected.size} selected
+          </span>
+        </div>
+
+        <ul className="flex max-h-72 flex-col gap-1 overflow-y-auto">
+          {backlog.map((row, index) => {
+            const key = rowKey(row);
+            const inputId = `${rowIdPrefix}-${index}`;
+            return (
+              <li key={key}>
+                <label
+                  htmlFor={inputId}
+                  className="flex items-center gap-2 rounded-md px-1 py-1.5 text-sm text-foreground hover:bg-muted/50"
+                >
+                  <input
+                    id={inputId}
+                    type="checkbox"
+                    checked={selected.has(key)}
+                    onChange={() => toggleRow(key)}
+                    className="size-4 rounded border-input accent-primary"
+                    aria-label={`${row.itemName} — ${row.ruleName}`}
+                  />
+                  <span className="font-medium">{row.itemName}</span>
+                  <span className="text-muted-foreground">
+                    — {row.ruleName}
+                  </span>
+                </label>
+              </li>
+            );
+          })}
+        </ul>
+
+        <div className="grid gap-3 sm:grid-cols-2">
+          <Field
+            label="Date serviced"
+            controlId={dateId}
+            required
+            error={firstMessage(codes, DATE_CODES)}
+          >
+            <Input
+              id={dateId}
+              type="date"
+              value={servicedOn}
+              onChange={(e) => setServicedOn(e.target.value)}
+              aria-invalid={DATE_CODES.some((c) => codes.includes(c))}
+            />
+          </Field>
+          <Field label="Notes" controlId={notesId}>
+            <Textarea
+              id={notesId}
+              value={notes}
+              onChange={(e) => setNotes(e.target.value)}
+            />
+          </Field>
+        </div>
+
+        <div>
+          <Button
+            type="submit"
+            size="sm"
+            disabled={pending || selected.size === 0}
+          >
+            {pending ? "Marking…" : "Mark serviced"}
+          </Button>
+        </div>
+      </form>
+    </Card>
+  );
+}
diff --git a/app/(app)/summary/summary-tables.tsx b/app/(app)/summary/summary-tables.tsx
index 43471abc..21ef4efd 100644
--- a/app/(app)/summary/summary-tables.tsx
+++ b/app/(app)/summary/summary-tables.tsx
@@ -1,7 +1,7 @@
 "use client";
 
 // U8/KTD-8: `page.tsx` stays a server component that hand-aggregates via
-// `computeSummary()`; the aggregate rows it produces are fed straight into
+// `inventorySummary()`; the aggregate rows it produces are fed straight into
 // this thin client wrapper, which layers the shared `DataTable` (sort +
 // column show/hide + pagination only — no filter, no grouping, since the
 // rows are already aggregated) over each of the two roll-up tables.
@@ -14,16 +14,24 @@ import {
 } from "@/components/ui/data-table/types";
 import { Data } from "@/components/ui/typography";
 import { useTableViewState } from "@/hooks/use-table-view-state";
+import type { BacklogRow } from "@/src/domain/service-intervals/backlog";
 import type {
   CaliberCoverage,
   CaliberSummary,
   FirearmCount,
 } from "@/src/domain/summary/summary";
+import { ServiceBacklogControl } from "./service-backlog-control";
 
 interface SummaryTablesProps {
   byCaliber: CaliberSummary[];
   firearmCounts: FirearmCount[];
   caliberCoverage: CaliberCoverage[];
+  /** Visible items with at least one due service rule (U9, R19). */
+  itemsDue: number;
+  /** Total due service rules across the visible collection (U9, R19). */
+  rulesDue: number;
+  /** One row per due item-and-rule pair (R16) — feeds the bulk mark-serviced control. */
+  serviceBacklog: BacklogRow[];
 }
 
 /** Visible text for each `CaliberCoverage.reason` (R12) — never color alone. */
@@ -36,6 +44,9 @@ export function SummaryTables({
   byCaliber,
   firearmCounts,
   caliberCoverage,
+  itemsDue,
+  rulesDue,
+  serviceBacklog,
 }: SummaryTablesProps) {
   const caliberColumns = useMemo<ColumnDef<CaliberSummary>[]>(
     () => [
@@ -123,6 +134,24 @@ export function SummaryTables({
 
   return (
     <div className="grid gap-6 lg:grid-cols-2">
+      {/* U9/R19: breadth (items) and volume (rules) from one line, beside the
+          ammo low-stock roll-up below — never re-derives due state, only
+          reads the counts `computeServiceRollup` already folded into
+          `Summary`. */}
+      <section
+        aria-labelledby="service-due"
+        className="space-y-3 lg:col-span-2"
+      >
+        <h2 id="service-due" className="text-sm font-semibold text-foreground">
+          Service
+        </h2>
+        <Data>
+          {itemsDue} {itemsDue === 1 ? "item" : "items"} due for service across{" "}
+          {rulesDue} {rulesDue === 1 ? "rule" : "rules"}
+        </Data>
+        <ServiceBacklogControl backlog={serviceBacklog} />
+      </section>
+
       <section aria-labelledby="by-caliber" className="space-y-3">
         <h2 id="by-caliber" className="text-sm font-semibold text-foreground">
           By caliber
diff --git a/docs/plans/2026-08-02-002-feat-service-intervals-plan.md b/docs/plans/2026-08-02-002-feat-service-intervals-plan.md
new file mode 100644
index 00000000..39116650
--- /dev/null
+++ b/docs/plans/2026-08-02-002-feat-service-intervals-plan.md
@@ -0,0 +1,689 @@
+---
+title: Service Interval Tracking - Plan
+type: feat
+date: 2026-08-02
+topic: service-intervals
+artifact_contract: ce-unified-plan/v1
+artifact_readiness: implementation-ready
+product_contract_source: ce-brainstorm
+execution: code
+---
+
+# Service Interval Tracking - Plan
+
+## Goal Capsule
+
+- **Objective:** Give firearms and accessories named service rules that come due on elapsed days, range sessions, or rounds fired, so an owner who currently services on symptom or on recall can see what needs attention. Resolves GitHub issue #10.
+- **Product authority:** Owner (`unclesp1d3r`), via brainstorm. The Product Contract below is pinned; Key Technical Decisions own implementation mechanism within it.
+- **Open blockers:** None. Every product decision is pinned and every planning question is answered by a Key Technical Decision.
+- **Execution profile:** Work units in dependency order. Domain logic is test-first — the pure derivation in U2 is the correctness core and everything above it reads its output. Surfaces (U7–U9) follow the shipped detail-view patterns rather than inventing layout.
+- **Stop conditions:** Stop and surface a blocker if the conversion in U5 would lose or duplicate an existing `cleaned`/`lubed` entry, or if a decision here contradicts a Product Contract requirement. Details the plan leaves open are the implementer's call.
+- **Tail ownership:** The caller owns branch, commit, and PR. Do not open a PR from inside implementation.
+
+---
+
+## Product Contract
+
+**Preservation note:** Product Contract requirements, key decisions, flows, and acceptance examples are unchanged. The four Deferred-to-Planning questions are resolved and removed — each is now answered by a Key Technical Decision (OQ1 → KTD3, OQ2 → KTD7, OQ3 → KTD6, OQ4 → KTD8). One assumption was added recording that accessories are not a grantable parent type.
+
+### Summary
+
+A firearm or accessory carries named service rules — Cleaning, Barrel, Recoil spring — each due on whichever comes first of elapsed days, range sessions, or rounds fired. Rules inherit live from per-category owner defaults and can be overridden, suppressed, or added one rule at a time. `cleaned` and `lubed` stop being standalone log events and become seeded rules, so there is one way to record service and existing entries become real service points. Every count and every due state is derived on read.
+
+### Problem Frame
+
+The owner services on symptom or on recall — when something stops working right, or when it happens to come to mind. That is not a gap in the record; it is a gap in the prompt. Nothing tells the owner that a rifle has accumulated rounds since it was last touched.
+
+MagStacker already holds what the prompt needs. `range_session` records rounds fired per firearm per trip, and `range_session_accessory` snapshots which accessories were mounted on each one, so rounds and outings are already attributable down to the part. The inventory log already records `cleaned` and `lubed` against firearms with an actor and a timestamp.
+
+None of it connects. A `cleaned` entry is a bare fact with no interval to measure against, so cleaning history accumulates without ever saying whether cleaning is due. The data that would answer the question and the record of the act sit one join apart and have never been introduced.
+
+Firearms also have no acquired date — magazines and ammo both carry one, firearms do not — so the only date a firearm owns is when its record was typed in.
+
+### Key Decisions
+
+- KD1. **Multiple named rules per item.** A rifle needs cleaning, a barrel, and a recoil spring on three separate clocks, and one interval per item cannot express that. (session-settled: user-directed — chosen over one interval per item, and over modeling each part as a separate accessory.) Governs R1, R2.
+- KD2. **Live per-rule inheritance from owner category defaults.** Raising the rifle barrel default reaches every rifle that has not overridden that specific rule; a frozen copy would strand them. (session-settled: user-directed — chosen over whole-set detach on first edit, and over apply-on-demand templates.) Governs R3, R4, R5.
+- KD3. **Three axes, first to trip wins.** Days, range sessions, and rounds fired are all already derivable from logged data, so the third axis costs nothing to add. (session-settled: user-directed.) Governs R2, R7.
+- KD4. **`cleaned` and `lubed` become seeded rules.** One verb for service means one entry, one history, and one vocabulary; keeping both would leave two ways to record a cleaning where only one moves the clock. (session-settled: user-directed — chosen over keeping the event types alongside service events, and over a separate service history.) Governs R13, R14, R15.
+- KD5. **Nothing about service state is stored.** Last service point, elapsed counts, and due state are derived on read, matching Lifetime Total, Last Inventoried, and Low Stock. The issue's proposed `lastServicedAt` / `lastServicedRounds` columns are rejected. (session-settled: user-approved.) Governs R12.
+- KD6. **Entry into MagStacker is day one.** With no service history to inherit, measurement starts at the item's origin date, which makes day-one totals large and honest rather than zeroed. (session-settled: user-directed.) Governs R10, R16.
+- KD7. **Advisory only.** Service state informs and never gates; there is no enforcement, no nagging, and no compliance concept. (session-settled: user-directed.) Governs R21.
+- KD8. **Binary due, and the roll-up lands on `/summary`.** A "due soon" tier and a dedicated maintenance view both add surface without adding signal at this size. (session-settled: user-approved.) Governs R11, R19.
+- KD9. **Firearms gain an acquired date inside this plan.** It mirrors what magazines and ammo already carry, and it is what makes the day axis measure something real. (session-settled: user-directed.) Governs R22.
+- KD10. **Accessory category defaults key on the category string as typed.** Accessory `category` stays free text, so two spellings of one category are two unrelated default sets and an accessory whose category matches no default simply inherits nothing. (session-settled: user-directed — chosen over per-item-only rules for accessories, and over converting category to a controlled list.) Governs R3.
+
+### Requirements
+
+**Service rules and inheritance**
+
+- R1. A firearm or accessory carries zero or more named service rules, each tracking one maintenance concern.
+- R2. A rule's name is unique within its item, and the rule sets at least one of three thresholds: elapsed days, range sessions, or rounds fired.
+- R3. An owner defines a default rule set per category — firearm type for firearms, accessory category as typed for accessories. An item whose category matches no default set inherits no rules.
+- R4. An item inherits its category's default rules live, so changing a default threshold reaches every item that has not overridden that rule.
+- R5. Each inherited rule on an item is inherited, overridden with item-specific thresholds, or suppressed; an item may also carry item-only rules no default defines. Overrides reset to inherited and suppressions restore.
+- R6. Rules and defaults belong to the item's owner, so a shared item's rules come from its owner's defaults rather than the viewer's.
+
+```mermaid
+flowchart TB
+  D["Owner default set for the item's category"] --> M{"Item has an entry<br/>for this rule name?"}
+  M -->|"no"| I["Inherited — tracks the default"]
+  M -->|"yes, thresholds"| O["Overridden — item's own thresholds"]
+  M -->|"yes, suppressed"| S["Suppressed — not tracked on this item"]
+  X["Item-only rule with no matching default"] --> P["Tracked, unaffected by default changes"]
+  I --> E["Effective rule set for the item"]
+  O --> E
+  P --> E
+```
+
+**Due computation**
+
+- R7. A rule is due when any threshold it sets is met or exceeded, measured since that rule's last service point.
+- R8. Days elapse from the last service point's date; sessions and rounds count range sessions dated after it.
+- R9. For an accessory, sessions and rounds count only the range sessions on which that accessory was recorded as mounted.
+- R10. A rule with no service point measures from its item's origin date: the acquired date when set, otherwise the date the record was created.
+- R11. Due state is binary. Distance past a threshold is shown as the raw counts, not as a separate severity level.
+- R12. No service state is stored. Last service point, elapsed counts, and due state are derived on read.
+
+```mermaid
+flowchart TB
+  RS["range_session — date, rounds fired"] --> C["Sessions and rounds since the service point"]
+  RSA["range_session_accessory — mounted snapshot"] --> C
+  SE["Latest service event for this rule"] --> C
+  SE --> DAYS["Days since the service point"]
+  ORIGIN["Item origin date — acquired, else created"] -.->|"when no service event exists"| C
+  ORIGIN -.-> DAYS
+  C --> DUE{"Any threshold met?"}
+  DAYS --> DUE
+  DUE --> OUT["Due — derived, never stored"]
+```
+
+**Service events and history**
+
+- R13. `cleaned` and `lubed` stop being standalone inventory-log event types, and logging service against a rule becomes the single way to record either act.
+- R14. A service event records one rule, the date it happened, the acting user, and optional notes, and sets that rule's last service point.
+- R15. Existing `cleaned` and `lubed` entries convert to service events on seeded Cleaning and Lubrication rules, preserving their date, actor, and notes.
+- R16. An owner can mark one or many items serviced as of a date in a single action, so the day-one backlog clears without visiting each item.
+- R17. Each item shows its service history — every service event, newest first, naming the rule it serviced.
+
+**Surfaces**
+
+- R18. A firearm or accessory detail view lists its rules with thresholds, elapsed counts, inheritance state, and due state, and offers logging service against any of them.
+- R19. `/summary` carries a service roll-up of due rules across the collection, beside the existing ammo low-stock roll-up.
+- R20. Firearm and accessory list views indicate that an item has at least one due rule.
+- R21. Service state is advisory: it never blocks creating, editing, sharing, or using a record, and raises no interruptions or confirmations.
+
+**Supporting data**
+
+- R22. A firearm carries an optional acquired date, nullable and editable, mirroring what magazines and ammo already hold.
+
+### Key Flows
+
+- F1. Arming the collection from settings
+  - **Trigger:** Owner opens service-interval defaults with no rules configured anywhere.
+  - **Steps:** Owner sets thresholds for a firearm type; every firearm of that type immediately resolves an inherited rule; the `/summary` roll-up and list indicators populate without touching any item.
+  - **Outcome:** A collection-wide due picture from one settings edit.
+  - **Covered by:** R3, R4, R10, R19, R20
+
+- F2. Logging service
+  - **Trigger:** Owner finishes cleaning a rifle and opens its detail view.
+  - **Steps:** Owner logs service against the Cleaning rule with today's date and optional notes; that rule's counts reset to zero and its due state clears; the event joins the item's service history.
+  - **Outcome:** One act, one entry, and every rule on the item still measured independently.
+  - **Covered by:** R7, R14, R17, R18
+
+- F3. Diverging one rule from its default
+  - **Trigger:** One rifle needs a shorter barrel interval than the rifle default.
+  - **Steps:** Owner overrides the Barrel rule on that item; its other inherited rules are untouched; a later change to the rifle barrel default leaves the override standing but still reaches every other rifle.
+  - **Outcome:** Per-rule divergence without detaching the item from its category.
+  - **Covered by:** R4, R5
+
+### Acceptance Examples
+
+- AE1. Inheritance survives an unrelated override
+  - **Covers R4, R5.**
+  - **Given:** The Rifle default set has Cleaning 500 rounds and Barrel 5000 rounds, and an AR-15 overrides Barrel to 4000.
+  - **When:** The owner raises the Rifle Barrel default to 6000.
+  - **Then:** The AR-15's Barrel rule stays at 4000, and its Cleaning rule still tracks the Rifle default.
+
+- AE2. First threshold to trip wins
+  - **Covers R2, R7.**
+  - **Given:** A rule sets 180 days and 500 rounds, and its last service point was 20 days and 640 rounds ago.
+  - **When:** Due state is computed.
+  - **Then:** The rule is due, on rounds.
+
+- AE3. Cold start counts from the origin date
+  - **Covers R10.**
+  - **Given:** A firearm has an acquired date, 1,400 rounds logged since, and no service event on its Cleaning rule.
+  - **When:** Due state is computed against a 500-round threshold.
+  - **Then:** The rule is due, with 1,400 rounds and the days since the acquired date shown as the elapsed counts.
+
+- AE4. Accessory counts only its mounted sessions
+  - **Covers R9.**
+  - **Given:** A suppressor was recorded as mounted on two of a firearm's five range sessions since its last service point.
+  - **When:** Its elapsed counts are computed.
+  - **Then:** Only those two sessions and their rounds count, not the firearm's full total for the period.
+
+- AE5. A suppressed rule does not surface
+  - **Covers R5, R19, R20.**
+  - **Given:** An item suppresses an inherited rule whose thresholds it would otherwise exceed.
+  - **When:** The `/summary` roll-up and list indicators are computed.
+  - **Then:** That rule appears nowhere, and the item is not marked due on its account.
+
+- AE6. Converted history becomes a real service point
+  - **Covers R15.**
+  - **Given:** A firearm has a `cleaned` inventory-log entry from three months ago and none since.
+  - **When:** The conversion runs and due state is computed against the Cleaning rule.
+  - **Then:** The rule measures from that entry's date rather than the item's origin date, and the entry appears in service history as a Cleaning event.
+
+### Scope Boundaries
+
+**Deferred for later**
+
+- Reminders that leave the app — push, email, or anything scheduled. No background job system exists to deliver them; this belongs to its own follow-up issue.
+- A "due soon" tier or any severity gradation above binary due.
+- Projecting when a rule *will* come due from usage rate.
+- Service rules on magazines and ammo. Both are owned parents and could carry rules later; this plan covers firearms and accessories only.
+- Parts, cost, or vendor tracking attached to a service event.
+
+**Outside this plan's identity**
+
+- Any enforcement of service state. Nothing is blocked, gated, escalated, or scored on maintenance compliance. Per R21 this is a prompt, not a policy.
+
+**Deferred to follow-up work**
+
+- Converting accessory `category` to a controlled list. This would contradict KD10, which settles category as free text with exact-string matching, so it stays out of scope; the accessory form instead offers the owner's own previously-typed categories as suggestions, which reduces the typo risk KD10 creates without changing the matching rule.
+- CSV export of service rules or events. The existing exports in `src/domain/csv/` cover inventory shape, not activity, and this plan adds no export surface.
+
+**Scope added during implementation**
+
+Three items were pulled in after the plan was approved, each recorded here so the boundary list stays honest:
+
+- An acquired date on accessories, parallel to R22 for firearms. Originally deferred, but leaving it out reproduced on accessories exactly the cold-start problem KD6 exists to prevent — an accessory owned for years but entered today read as not-due on day one.
+- Editing and deleting a service event. The plan had no correction path, and because due state derives from the latest event per rule, one mis-logged entry skewed that rule permanently with no in-app recovery.
+- The accessory form offering the owner's existing categories as suggestions, per the first bullet above.
+
+### Dependencies / Assumptions
+
+- Issue #11 (shot count tracking) and issue #8 (accessories tracker) are both shipped, so rounds, sessions, and mounted-accessory attribution are real data, not planned data.
+- Issue #46 (inventory log) is shipped. This plan retires two of its three firearm event types (R13) and converts their existing rows (R15); `inventoried` and the Last Inventoried derivation are untouched.
+- `range_session_accessory` rows are snapshotted when a session is created, so accessory attribution exists only for sessions created after #8 shipped. Accessory counts under-report against older sessions, and no backfill is possible.
+- `service_event.serviced_on` is the calendar day the work happened; `service_event.created_at` is when the row was inserted. Both exist for the same reason `inventory_log` carries `occurred_at` and `created_at` — history sorts newest-first by `serviced_on`, then by `created_at` so several rules logged on one day have a stable order, and the R15 conversion has somewhere to carry the source row's insertion time.
+- Accessory `category` is free text with suggestions only (`src/domain/accessories/constants.ts`), never validated; firearm type is a controlled list (`src/domain/firearms/constants.ts`). Per KD10 the accessory side relies on the owner typing categories consistently, which the existing combobox supports but does not enforce.
+- An accessory's `installed_date` is cleared whenever the accessory is unmounted, enforced in the service layer and backed by a CHECK constraint, so it cannot serve as a stable origin date. R10 instead resolves an accessory's origin date the same way as a firearm's: `acquired_date` when set, otherwise `created_at`.
+- Accessories are not a grantable parent type — `ParentType` in `src/auth/visibility.ts` is `firearm | magazine | ammo`, and the `grant_parent_type_valid` CHECK matches. R6 is therefore only ever exercised by firearms; accessory rules, defaults, and service are owner-only in practice.
+- A firearm whose `type` is still the backfill sentinel `unspecified` resolves defaults against that sentinel like any other category value. It inherits nothing unless the owner deliberately defines an `unspecified` default set.
+
+### Sources / Research
+
+- GitHub issue #10 — original scoping, including the Phase 1 / Phase 2 split this plan preserves.
+- `src/db/inventory-schema.ts` — `inventory_log` (polymorphic parent, per-family event-type CHECK), `range_session`, `range_session_accessory`, `accessory`, `grant`, and the absence of an acquired date on `firearm`.
+- `src/domain/inventory-log/constants.ts` — `FIREARM_LOG_EVENTS` / `MAGAZINE_LOG_EVENTS`, the single source the DB CHECK is generated from; R13 changes this file.
+- `src/domain/inventory-log/last-inventoried.ts` — `loadLastInventoriedBatch`, the batched grouped-`max` shape the last-service-point loader mirrors.
+- `src/domain/range-sessions/service.ts` — `lifetimeRoundTotals` and `accessoryRoundsFired`; the latter is the visible-firearm-scoped accessory attribution R9 depends on.
+- `src/domain/summary/summary.ts` — `computeSummary`, the pure in-memory aggregation the due roll-up follows.
+- `src/backup/table-order.ts` — every persistent table must be registered or it is silently dropped from backups; `src/backup/maintenance.ts` guards the coverage.
+- `src/db/migrations/0008_brown_bulldozer.sql` — the hand-written polymorphic cleanup trigger this plan avoids needing (KTD2).
+- `docs/solutions/test-failures/timezone-fragile-date-boundary-tests.md` — local-vs-UTC day-boundary drift; governs KTD5 and every date test in this plan.
+- `docs/plans/2026-07-06-001-feat-inventory-log-plan.md` — the shipped inventory-log design this plan narrows.
+- `docs/plans/2026-07-07-001-feat-accessories-tracker-plan.md` — the mount-snapshot design R9 depends on.
+- `CONCEPTS.md` — child record, derived value, and owner-scoping conventions this plan follows.
+
+---
+
+## Planning Contract
+
+### Key Technical Decisions
+
+- KTD1. **A service event names its rule by name, not by reference to a rule row.** A rule's identity is already its name — that is what the Product Contract's inheritance resolution keys on (R5), and what makes a default and an item override the same rule. Events therefore carry `rule_name` and a rule row is never required for an event to exist. (session-settled: user-approved — chosen over a foreign key to a rule row: converting existing `cleaned`/`lubed` entries would then have to invent threshold values for seeded rule rows, which R2 forbids leaving empty.) Trade-off: renaming a rule on an item detaches its history unless the rename re-points its events, so U3 renames the events in the same transaction. Cites R5, R14, R15.
+- KTD2. **Service rows attach to a firearm or an accessory through two nullable foreign keys with an exactly-one CHECK**, not the `parent_type`/`parent_id` shape used by `grant` and `inventory_log`. Real foreign keys give native `ON DELETE CASCADE`, so no hand-written cleanup trigger of the kind `0002_grant_cleanup_triggers.sql` and `0008_brown_bulldozer.sql` carry is needed. (session-settled: user-approved — chosen over extending the polymorphic pattern for consistency.) Cites R1.
+- KTD3. **An edit-grantee may log service on a shared firearm; configuring rules and defaults is owner-only, and accessories are owner-only throughout.** Logging routes through `authorizeUpdate`, which is exactly what `cleaned` permits today — so the R15 conversion preserves capability an edit-grantee already had rather than silently revoking it. Rules and defaults are configuration of what the *owner* is prompted about, so they take `authorizeOwnerOnlyUpdate`. Accessories are not a grantable parent type at all, so every accessory path is owner-only by construction. (session-settled: user-approved.) Cites R6, R14, R18.
+- KTD4. **Elapsed counts are aggregated in memory over loaded session rows, not in SQL.** Each rule measures from its own service point, so a single grouped aggregate cannot serve them; loading `(firearm_id, date, rounds_fired)` for the visible set and folding per rule mirrors how `computeSummary` already aggregates the whole inventory in memory, and it makes the due computation a pure function that tests without a database. Cites R7, R8, R9, R12.
+- KTD5. **Every calendar comparison happens in the local frame.** Service dates, session dates, and acquired dates are stored as Postgres `date` (no time component), matching `range_session.date` and `magazine.acquired_date`, and are compared as calendar days rather than instants. Test fixtures construct dates with `new Date(y, monthIndex, d)`, never UTC `...Z` literals, per `docs/solutions/test-failures/timezone-fragile-date-boundary-tests.md`. Cites R8, R10.
+- KTD6. **Suppression is a boolean on the item's rule row**, not a separate exclusion list. A suppressed rule and an overridden rule are the same thing — an item-level entry for a rule name — differing only in whether thresholds are set, so one row shape carries both and restoring a suppression is deleting the row. Cites R5.
+- KTD7. **The conversion creates service events only; it seeds no rule rows.** Falls out of KTD1: a converted `cleaned` entry becomes a `Cleaning` event that any later Cleaning rule measures from. An owner who never logged `cleaned` or `lubed` gets nothing, and no threshold is invented on the owner's behalf. Cites R15.
+- KTD8. **The defaults surface offers the owner's own distinct accessory categories, derived on read.** KD10 makes a typo cost the owner a whole default set, and the defaults screen is where the owner types a category with no accessory in front of them. A `SELECT DISTINCT category` over the owner's accessories is the cheapest way to hold KD10's consistency assumption; no new table, and nothing like `magazine_label_prefix` is introduced. Cites R3.
+- KTD9. **Origin date resolves identically for both families:** `acquired_date` when set, otherwise `created_at` as a calendar date. Accessories gained their own `acquired_date` column during implementation (see Scope added during implementation) precisely so they follow this same rule rather than always falling back to `created_at` — the fallback-only version reproduces the cold-start problem KD6 exists to prevent, for any accessory owned before it was entered into MagStacker. Accessories still cannot use `installed_date` as an origin date; it is force-nulled on unmount. Cites R10, R22.
+- KTD10. **Sessions and rounds count strictly after the measure-from date.** R8 says "dated after", so a session on the same calendar day as the service point does not count toward the next interval. The same rule applies to the cold-start case, where the measure-from date is the item's origin date. Cites R8, R10.
+
+### High-Level Technical Design
+
+Three new tables. `service_rule_default` is owner-scoped and keyed by category; `service_rule` and `service_event` are item children reached through whichever of the two nullable foreign keys is set.
+
+```mermaid
+erDiagram
+  user ||--o{ service_rule_default : "owns"
+  user ||--o{ firearm : "owns"
+  user ||--o{ accessory : "owns"
+  firearm ||--o{ service_rule : "0..1 parent"
+  accessory ||--o{ service_rule : "0..1 parent"
+  firearm ||--o{ service_event : "0..1 parent"
+  accessory ||--o{ service_event : "0..1 parent"
+  firearm ||--o{ range_session : "rounds and outings"
+  range_session ||--o{ range_session_accessory : "mount snapshot"
+  accessory ||--o{ range_session_accessory : "mounted on"
+
+  service_rule_default {
+    uuid id PK
+    text owner_id FK
+    text scope "firearm or accessory"
+    text category "firearm type, or accessory category as typed"
+    text name
+    int interval_days "nullable"
+    int interval_sessions "nullable"
+    int interval_rounds "nullable"
+  }
+  service_rule {
+    uuid id PK
+    uuid firearm_id FK "nullable"
+    uuid accessory_id FK "nullable"
+    text name
+    bool suppressed
+    int interval_days "nullable"
+    int interval_sessions "nullable"
+    int interval_rounds "nullable"
+  }
+  service_event {
+    uuid id PK
+    uuid firearm_id FK "nullable"
+    uuid accessory_id FK "nullable"
+    text rule_name
+    date serviced_on
+    text actor_id FK "nullable"
+    text notes
+    timestamp created_at "insertion order"
+  }
+```
+
+The derivation is one pure module fed by four loaders. Nothing above the pure layer decides due state.
+
+```mermaid
+flowchart TB
+  L1["Defaults for the owners of the visible items"] --> R["Resolve effective rules per item"]
+  L2["Item rule rows — overrides, suppressions, item-only"] --> R
+  L3["Latest serviced_on per item and rule name"] --> M["Measure-from date per rule"]
+  L4["Session rows: date, rounds, mounted accessories"] --> A["Fold sessions and rounds after measure-from"]
+  ORIGIN["Item origin date"] --> M
+  R --> M
+  M --> A
+  M --> D["Days elapsed"]
+  A --> DUE["Due state per rule"]
+  D --> DUE
+  DUE --> S1["Item detail panel"]
+  DUE --> S2["/summary roll-up"]
+  DUE --> S3["List indicators"]
+```
+
+### Assumptions and implementation constraints
+
+- New tables must be registered in `src/backup/table-order.ts` in FK-safe order or the coverage guard in `src/backup/maintenance.ts` fails and the tables are silently dropped from backups. Registration lands in the same unit as the schema.
+- The conversion casts `inventory_log.occurred_at` (a timestamp) to a calendar date. There is no stored offset to convert against, so an entry logged within a few hours of midnight can land on the neighbouring day. This is a one-time, bounded, unrecoverable-by-design imprecision on historical rows; do not build offset inference to avoid it.
+- The `unique(firearm_id, name)` and `unique(accessory_id, name)` constraints rely on Postgres treating NULLs as distinct, so accessory rows do not collide on the firearm-side constraint and vice versa.
+- Migrations are generated with `bun run db:generate` and then hand-edited where the generator cannot express the change — the data conversion in U5 and the CHECK replacement it depends on both require hand-written SQL in the generated file, following how `0008_brown_bulldozer.sql` carries its trigger.
+
+### Risks
+
+- **The conversion in U5 is irreversible.** Retired `inventory_log` rows are deleted after their service events are written, and the migration cannot be run backwards. Mitigation: reconcile row counts inside the same migration run and stop on any mismatch, and take a backup export before applying it to a database with real history. The plan does not add a down-migration; the existing backup path is the recovery route.
+- **Converted dates can shift a day.** Casting `occurred_at` to a calendar date resolves against the database session timezone, and no offset was ever stored. An entry logged near midnight can land on the neighbouring day. Bounded to historical rows, one time, and accepted rather than mitigated — do not build offset inference.
+- **KTD4 loads session rows for the whole visible set.** That is fine at personal-inventory scale and matches how `inventorySummary` already works, but it is unbounded in principle: the cost grows with total sessions, not with items due. Watch it on the `/summary` and list paths. If it ever becomes a problem, the fix is to push the fold into SQL, not to store the derived state — KD5 rules that out.
+- **Accessory counts under-report against pre-#8 sessions.** `range_session_accessory` only has rows for sessions created after the accessories tracker shipped, and no backfill is possible. An accessory's first intervals will read low; this is a data-history limit, not a defect to chase.
+
+### Sequencing
+
+U1 → U2 → U3 → U4 are the spine: schema, pure derivation, rule configuration, then events and roll-up loaders. U5 (the retirement and conversion) depends on U4's event writer existing but is otherwise independent of the surfaces. U6 is independent of everything except U1. U7 through U9 are surfaces over the completed service layer and can land in any order among themselves; U10 follows once all three have landed.
+
+---
+
+## Implementation Units
+
+| U-ID | Title | Key files | Depends on |
+|---|---|---|---|
+| U1 | Schema, migration, backup registration | `src/db/inventory-schema.ts`, `src/db/migrations/`, `src/backup/table-order.ts` | — |
+| U2 | Pure derivation core | `src/domain/service-intervals/{constants,validate,derive}.ts` | U1 |
+| U3 | Defaults and item-rule service layer | `src/domain/service-intervals/rules-service.ts` | U1, U2 |
+| U4 | Service events and batched roll-up loaders | `src/domain/service-intervals/{events-service,due-service}.ts` | U1, U2, U3 |
+| U5 | Retire `cleaned`/`lubed` and convert history | `src/domain/inventory-log/constants.ts`, `src/db/migrations/`, `app/(app)/inventory-log/log-entry-form.tsx` | U1, U4 |
+| U6 | Firearm acquired date | `src/domain/firearms/{validate,service}.ts`, `app/(app)/firearms/firearm-form.tsx` | U1 |
+| U7 | Service defaults settings surface | `app/(app)/settings/service/` | U3 |
+| U8 | Item detail surfaces | `app/(app)/firearms/firearm-detail-view.tsx`, `app/(app)/accessories/accessory-detail-view.tsx` | U4, U6 |
+| U9 | Roll-up surfaces | `app/(app)/summary/`, `app/(app)/firearms/firearms-view.tsx`, `app/(app)/accessories/accessories-view.tsx` | U4 |
+| U10 | Demo seed and end-to-end coverage | `src/demo/inventory.ts`, `e2e/service-intervals.spec.ts` | U7, U8, U9 |
+
+### U1. Schema, migration, and backup registration
+
+- **Goal:** The three service tables and the firearm acquired-date column exist, migrate cleanly, and are covered by backup.
+- **Requirements:** R1, R2, R5, R14, R22. Cites KTD2, KTD5, KTD6, KTD9.
+- **Dependencies:** none.
+- **Files:**
+  - `src/db/inventory-schema.ts` — add `serviceRuleDefault`, `serviceRule`, `serviceEvent`; add `acquiredDate` to `firearm`.
+  - `src/db/migrations/00NN_*.sql` — generated, then hand-checked for the exactly-one and threshold CHECKs.
+  - `src/backup/table-order.ts` — register all three tables in `EXPORT_TABLE_ORDER`.
+  - `src/test-support/factories.ts` — makers for the three new tables.
+  - `src/db/__tests__/` — schema-constraint tests.
+- **Approach:**
+  1. `service_rule_default`: owner-scoped, `unique(owner_id, scope, category, name)`, `scope` CHECKed to `('firearm','accessory')`, at least one threshold non-null, each non-null threshold `>= 1`.
+  2. `service_rule`: `num_nonnulls(firearm_id, accessory_id) = 1`; `unique(firearm_id, name)` and `unique(accessory_id, name)`; suppressed rows carry no thresholds and unsuppressed rows carry at least one.
+  3. `service_event`: same exactly-one parent CHECK; `rule_name` text; `serviced_on` as `date` per KTD5; `created_at` as a not-null defaulted timestamp so same-day events sort stably and the R15 conversion has somewhere to carry the source row's insertion time; `actor_id` FK to `user` with `ON DELETE SET NULL`, mirroring `inventory_log`'s reasoning about deleting a user who acted on someone else's shared item.
+  4. Index each table on its parent column and, for events, on `(parent, rule_name, serviced_on)` for the latest-service-point lookup.
+  5. Add `firearm.acquiredDate` as nullable `date`, matching `magazine.acquiredDate` and `ammo.acquiredDate`.
+  6. Register the three tables in `EXPORT_TABLE_ORDER` after `accessory` and extend the order-rationale comment.
+  7. Add factories for the three tables to `src/test-support/factories.ts`, matching the shape of the existing child-table makers, so later units build fixtures through them rather than hand-rolling inserts.
+- **Patterns to follow:** `accessory` and `rangeSessionAccessory` in `src/db/inventory-schema.ts` for owner-scoped and child-record shape; `magazine.acquiredDate` for the nullable calendar-date column; `src/backup/table-order.ts`'s existing comment for how new tables are justified in the order.
+- **Test scenarios:**
+  - A `service_rule` row with both `firearm_id` and `accessory_id` set is rejected by the database.
+  - A `service_rule` row with neither parent set is rejected.
+  - A `service_rule_default` row with all three thresholds null is rejected.
+  - A `service_rule_default` row with a zero or negative threshold is rejected.
+  - A suppressed `service_rule` row carrying a threshold is rejected.
+  - Two `service_rule` rows with the same name on the same firearm are rejected; the same two names on two different firearms are accepted.
+  - Two `service_rule` rows with the same name on two different accessories are accepted, proving the firearm-side unique does not collide across NULL parents.
+  - Deleting a firearm removes its `service_rule` and `service_event` rows without a trigger.
+  - Deleting the acting user leaves a `service_event` row in place with a null `actor_id`.
+  - `EXPORT_TABLE_ORDER` covers every persistent table — the existing backup coverage guard passes.
+- **Verification:** `bun run db:generate` produces no further diff, `bun run db:migrate` applies against a fresh database, and `bun test src/db src/backup` passes.
+
+### U2. Pure derivation core
+
+- **Goal:** Effective rule resolution, elapsed counts, and due state exist as pure functions with no database access.
+- **Requirements:** R2, R4, R5, R7, R8, R9, R10, R11, R12. Cites KTD4, KTD5, KTD6, KTD9, KTD10.
+- **Dependencies:** U1.
+- **Files:**
+  - `src/domain/service-intervals/constants.ts` — rule-name and threshold bounds, inheritance-state union.
+  - `src/domain/service-intervals/validate.ts` — pure validators returning all failure codes together.
+  - `src/domain/service-intervals/derive.ts` — `resolveEffectiveRules`, `elapsedCounts`, `isDue`.
+  - `src/domain/service-intervals/__tests__/{validate,derive}.test.ts`
+  - `CONCEPTS.md` — add Service Rule, Service Event, and Due as domain terms; this unit is where that vocabulary first becomes real.
+- **Approach:**
+  1. `resolveEffectiveRules(defaults, itemRules)` returns one entry per effective rule carrying name, thresholds, and inheritance state (`inherited` | `overridden` | `item-only`). A suppressed item rule removes the matching default from the result; a suppressed item rule with no matching default contributes nothing.
+  2. `elapsedCounts` takes the measure-from date and the item's session rows and folds days, sessions, and rounds. Sessions are counted only when strictly after the measure-from date per KTD10.
+  3. `isDue` returns true when any set threshold is met or exceeded, and reports which axis tripped so the surfaces can name it.
+  4. Validation rejects an empty or whitespace-only rule name, a duplicate name within one submitted set, and a threshold below 1; a rule with no threshold set is invalid unless it is suppressed.
+- **Execution note:** Write these tests first. This module is the correctness core — every surface reads its output, and it is the one layer that can be exhaustively tested without Docker.
+- **Patterns to follow:** `src/domain/summary/summary.ts` for the pure-aggregation-plus-thin-loader split; `src/domain/inventory-log/validate.ts` for the all-codes-together validator shape; `src/domain/firearms/constants.ts` for the value-set-plus-label module shape.
+- **Test scenarios:**
+  - Covers AE1. A default set of Cleaning 500 rounds and Barrel 5000 rounds against an item rule overriding Barrel to 4000 resolves Barrel at 4000 marked overridden and Cleaning at 500 marked inherited; raising the default Barrel to 6000 leaves the resolved Barrel at 4000.
+  - Covers AE2. A rule of 180 days and 500 rounds with 20 days and 640 rounds elapsed is due, and the tripped axis is rounds.
+  - Covers AE5. A suppressed item rule whose matching default would otherwise be exceeded contributes no entry to the resolved set.
+  - An item rule with no matching default resolves as item-only and is unaffected by any default in the set.
+  - A suppressed item rule with no matching default contributes nothing and raises no error.
+  - Empty defaults and empty item rules resolve to an empty rule set, not an error.
+  - A rule setting only days is not due when only rounds have accumulated past a value the rule does not set.
+  - A rule exactly at its threshold is due — the comparison is met-or-exceeded, not exceeded.
+  - A session dated the same calendar day as the measure-from date does not count toward sessions or rounds; a session one day later does.
+  - Elapsed counts computed with fixtures built as `new Date(y, monthIndex, d)` are stable when the suite runs under a non-UTC `TZ`.
+  - Validation rejects an empty rule name, a whitespace-only rule name, a duplicate name in one set, a zero threshold, and a negative threshold, returning every applicable code in one call.
+- **Verification:** `bun test src/domain/service-intervals` passes, and passes again under `TZ=Asia/Tokyo` and `TZ=America/New_York`.
+
+### U3. Defaults and item-rule service layer
+
+- **Goal:** An owner can create, edit, and delete category defaults and per-item rule overrides, suppressions, and item-only rules, with authorization enforced.
+- **Requirements:** R1, R2, R3, R4, R5, R6. Cites KTD1, KTD3, KTD6, KTD8.
+- **Dependencies:** U1, U2.
+- **Files:**
+  - `src/domain/service-intervals/rules-service.ts` — defaults CRUD, item-rule CRUD, owner accessory-category listing.
+  - `src/domain/service-intervals/__tests__/rules-service.test.ts`
+- **Approach:**
+  1. Defaults are owner-scoped with no grant path: every read and write filters on `owner_id = actorId`.
+  2. Item-rule writes take `authorizeOwnerOnlyUpdate` for firearms per KTD3; accessory writes resolve the accessory's owner directly, since accessories have no `authorize.ts` gate (`accessories/service.ts` already resolves permission itself).
+  3. Reads of a *firearm's* rules resolve through the firearm's own visibility so a view-grantee can see a shared firearm's rules; `NotFoundError` for an unseen item so existence is never revealed. Reads of an *accessory's* rules and history check accessory ownership directly and never route through the shared-item visibility path — accessory permission otherwise inherits from the mounted firearm, which would hand a firearm grantee configuration KTD3 reserves to the owner.
+  4. Renaming an item rule re-points that item's `service_event` rows with the old `rule_name` in the same transaction, per KTD1's trade-off. Reject a rename onto a name the same item already uses with the existing duplicate-name `ValidationError` before the write, so the uniqueness constraint is never the thing that surfaces the error.
+  5. Expose the owner's distinct accessory categories for the defaults surface per KTD8 — a `SELECT DISTINCT category` over the owner's accessories, ordered alphabetically.
+  6. Validate before opening the transaction, matching `createLogEntry`.
+- **Patterns to follow:** `src/domain/inventory-log/service.ts` for validate-then-authorize-in-transaction ordering and for the per-parent-family authorization split; `src/domain/accessories/service.ts` for accessory-side permission resolution outside `authorize.ts`.
+- **Test scenarios:**
+  - Covers AE1. Creating a Rifle default set, overriding Barrel on one AR-15, then raising the Rifle Barrel default leaves that AR-15's Barrel override untouched and every other rifle tracking the new value.
+  - Covers R5. Deleting an item's override restores the inherited default; deleting a suppression restores the rule.
+  - Suppressing a rule stores a suppressed row rather than deleting the default.
+  - A default set defined for one owner is invisible to another owner with an identically-named category.
+  - An edit-grantee attempting to create, edit, or delete an item rule on a shared firearm is rejected.
+  - A view-grantee reading a shared firearm's rules receives the owner's resolved rules, not their own defaults.
+  - A user with no visibility on a firearm receives `NotFoundError` rather than a permission error when reading its rules.
+  - Renaming an item rule carries that item's service events to the new name and leaves an identically-named rule on a different item alone.
+  - Renaming an item rule onto a name that item already carries throws `ValidationError` and leaves both rules and their events unchanged.
+  - A firearm's view-grantee reading an accessory's rules or history is rejected, even when that accessory is mounted on the shared firearm.
+  - An invalid rule (empty name, no thresholds and not suppressed) throws `ValidationError` and writes no row.
+  - The accessory-category listing returns each of the owner's distinct categories once, alphabetically, and excludes another owner's categories.
+- **Verification:** `bun test src/domain/service-intervals` passes; Docker is required because these are Testcontainers integration tests.
+
+### U4. Service events and batched roll-up loaders
+
+- **Goal:** Service can be logged against a rule on one or many items, history reads back, and due state is computable across a whole visible collection in a bounded number of queries.
+- **Requirements:** R7, R8, R9, R10, R12, R14, R16, R17, R19, R20. Cites KTD1, KTD3, KTD4, KTD9, KTD10.
+- **Dependencies:** U1, U2, U3.
+- **Files:**
+  - `src/domain/service-intervals/events-service.ts` — log one, log many, list history.
+  - `src/domain/service-intervals/due-service.ts` — per-item and collection-wide due resolution.
+  - `src/domain/service-intervals/__tests__/{events-service,due-service}.test.ts`
+- **Approach:**
+  1. Logging a firearm service event takes `authorizeUpdate` (edit-grantee allowed, KTD3); accessory events are owner-only. `actorId` is always the acting user, never caller-supplied.
+  2. The bulk mark-serviced path (R16) accepts a set of item-and-rule pairs and a single date, authorizes each item **with the same per-family rules as single logging** — edit-grantee allowed on firearms, owner-only on accessories — and writes in one transaction, rejecting the whole batch if any item fails authorization. Bulk is a convenience over the single path, not a higher-privilege one; giving it a stricter gate than the loop it replaces would be a rule nobody could infer from R16.
+  3. `due-service` loads, for a visible set: the owners of those items, their defaults, the items' rule rows, the latest `serviced_on` per item and rule name, and the session rows. It then calls U2's pure functions. Nothing here decides due state.
+  4. The latest-service-point loader is a grouped `max(serviced_on)` over the visible ids, mirroring `loadLastInventoriedBatch`. An item and rule with no event is absent from the map, which the caller reads as "measure from origin".
+  5. Accessory session attribution joins `range_session_accessory` to `range_session` and restricts to firearms in the requester's visible set, exactly as `accessoryRoundsFired` does — otherwise a remounted accessory leaks rounds from a firearm the actor cannot see.
+- **Patterns to follow:** `src/domain/inventory-log/last-inventoried.ts` for the batched grouped-`max` Map return; `src/domain/range-sessions/service.ts`'s `accessoryRoundsFired` for the visible-firearm restriction on accessory attribution; `src/domain/summary/summary.ts`'s `inventorySummary` for the load-then-apply-pure-function split.
+- **Test scenarios:**
+  - Covers AE3. A firearm with an acquired date, 1,400 rounds logged since, and no service event resolves as due against a 500-round Cleaning threshold, reporting 1,400 rounds and the days since the acquired date.
+  - Covers AE4. A suppressor mounted on two of a firearm's five post-service sessions counts only those two sessions and their rounds.
+  - Covers AE6. A firearm with a converted `cleaned` service event three months old measures from that date rather than its origin date, and the event appears in its history.
+  - Covers R14. Logging service resets that rule's counts to zero and leaves every other rule on the item at its prior counts.
+  - Covers R16. A bulk mark-serviced call across several items writes one event per item-and-rule pair with the given date.
+  - A bulk mark-serviced call containing one unauthorized item writes nothing at all.
+  - An edit-grantee's bulk mark-serviced call across shared firearms succeeds, matching what the single-event path already allows them.
+  - An edit-grantee can log service on a shared firearm; the event records the grantee as actor.
+  - A non-owner cannot log service on an accessory even when they can see the firearm it is mounted to.
+  - A firearm with no acquired date measures from its creation date.
+  - An accessory with an acquired date measures from that date; one without measures from its creation date, not its installed date.
+  - Service history returns events newest first and names the rule each serviced.
+  - Collection-wide due resolution over an owner with no defaults anywhere returns an empty result, not an error.
+  - Collection-wide due resolution includes a shared firearm using its owner's defaults, not the viewer's.
+  - Collection-wide due resolution issues a bounded number of queries regardless of how many items are visible — no per-item query.
+  - An accessory whose only mounted sessions belong to a firearm the actor cannot see contributes no rounds.
+- **Verification:** `bun test src/domain/service-intervals` passes.
+
+### U5. Retire `cleaned` and `lubed` and convert existing history
+
+- **Goal:** `cleaned` and `lubed` no longer exist as inventory-log event types, and every existing entry survives as a service event.
+- **Requirements:** R13, R15. Cites KTD1, KTD7.
+- **Dependencies:** U1, U4.
+- **Files:**
+  - `src/domain/inventory-log/constants.ts` — `FIREARM_LOG_EVENTS` narrows to `["inventoried"]`.
+  - `src/db/migrations/00NN_*.sql` — hand-written conversion, delete, and CHECK replacement.
+  - `app/(app)/inventory-log/log-entry-form.tsx` — event-type options.
+  - `src/domain/inventory-log/__tests__/{service,validate}.test.ts` — update assertions.
+  - `e2e/inventory-log.spec.ts` — update the spec that selects `cleaned` and `lubed`.
+- **Approach:**
+  1. Insert one `service_event` per firearm `cleaned` or `lubed` entry, mapping `cleaned` to `Cleaning` and `lubed` to `Lubrication`, preserving `actor_id`, `notes`, and `created_at`, and casting `occurred_at` to a date.
+  2. Delete the converted `inventory_log` rows.
+  3. Replace `inventory_log_event_type_valid` with the narrowed firearm list. The CHECK replacement must follow the delete or the migration fails on its own historical rows.
+  4. Narrow `FIREARM_LOG_EVENTS` and let the schema's generated CHECK follow from it.
+  5. Drop the retired options from the log-entry form's event-type select.
+- **Execution note:** Verify row counts before and after the conversion in the same migration run — this is the one irreversible data step in the plan. Stop and surface a blocker if any entry would be lost or duplicated.
+- **Patterns to follow:** `src/db/migrations/0008_brown_bulldozer.sql` for hand-written SQL living alongside generated statements in one migration file.
+- **Test scenarios:**
+  - Covers AE6. A firearm with one three-month-old `cleaned` entry ends the migration with one `Cleaning` service event on that date and no `cleaned` log row.
+  - A `lubed` entry converts to a `Lubrication` event preserving actor and notes.
+  - An `inventoried` entry is untouched by the conversion and still feeds the Last Inventoried derivation.
+  - The converted event count equals the pre-migration `cleaned` plus `lubed` count.
+  - A magazine's `inventoried` entries are untouched.
+  - Creating a log entry with `eventType: "cleaned"` now throws `ValidationError` and writes no row.
+  - The database rejects a direct insert of a `cleaned` row after the CHECK is replaced.
+  - The log-entry form offers only `inventoried` for a firearm.
+- **Verification:** `bun run db:migrate` applies against a database seeded with pre-migration `cleaned` and `lubed` rows; `bun test src/domain/inventory-log` and `bun run test:e2e -- inventory-log` pass.
+
+### U6. Firearm acquired date
+
+- **Goal:** A firearm carries an editable, optional acquired date that the day axis measures from.
+- **Requirements:** R22, R10. Cites KTD9.
+- **Dependencies:** U1.
+- **Files:**
+  - `src/domain/firearms/validate.ts` — accept and validate the optional date.
+  - `src/domain/firearms/service.ts` — carry it through create and update.
+  - `app/(app)/firearms/firearm-form.tsx` — the input.
+  - `app/(app)/firearms/firearm-detail-view.tsx` — display when set.
+  - `src/domain/firearms/__tests__/` — validation and service coverage.
+- **Approach:** Mirror how `magazine.acquiredDate` is validated, stored, and rendered end to end. Null means unset, not "unknown but zero", and a firearm without one is unremarkable rather than incomplete.
+- **Patterns to follow:** the magazine acquired-date path across `src/domain/magazines/validate.ts`, `src/domain/magazines/service.ts`, and the magazine form.
+- **Test scenarios:**
+  - Creating a firearm without an acquired date stores null and the detail view omits the field.
+  - Setting an acquired date persists it and the detail view renders it.
+  - Clearing a previously-set acquired date stores null.
+  - A malformed date string is rejected with a validation code and no row is written.
+  - A future acquired date is accepted or rejected consistently with how the magazine path treats one.
+  - A firearm with an acquired date reports that date as its origin date; one without reports its creation date.
+- **Verification:** `bun test src/domain/firearms` passes and `bun run typecheck` is clean.
+
+### U7. Service defaults settings surface
+
+- **Goal:** An owner configures per-category default rules from settings and sees the effect without visiting an item.
+- **Requirements:** R3, R4, R6. Cites KTD8, KTD10.
+- **Dependencies:** U3.
+- **Files:**
+  - `app/(app)/settings/service/page.tsx` — the defaults surface.
+  - `app/(app)/settings/service/service-defaults-form.tsx` — per-category rule editing.
+  - `app/(app)/settings/service/actions.ts` — server actions.
+  - `app/(app)/settings/service/__tests__/actions.test.ts`
+  - `app/(app)/settings/page.tsx` — link through to the service-defaults sub-route.
+- **Approach:**
+  1. A dedicated sub-route rather than an addition to the account-preferences form — `app/(app)/settings/page.tsx` is a thin preferences surface and this is a collection-wide configuration screen. That page gains a link into the sub-route, so the screen that arms the whole feature is reachable without typing a URL.
+  2. Firearm categories come from `FIREARM_TYPES` with their existing labels. Accessory categories come from the owner's own distinct categories per KTD8, with free entry still permitted so a category with no accessory yet can be armed in advance.
+  3. Editing a default states plainly how many items it reaches, so the live-inheritance consequence in R4 is visible before saving.
+  4. Server actions carry the owner-only gate; the page never trusts a client-supplied owner.
+- **Patterns to follow:** `app/(app)/settings/actions.ts` and `app/(app)/settings/settings-form.tsx` for the server-action-plus-form shape; `src/domain/firearms/constants.ts`'s label maps for rendering type slugs.
+- **Test scenarios:**
+  - Covers F1. Setting a rifle default with no rules configured anywhere makes every rifle resolve an inherited rule.
+  - Saving a default with an empty rule name surfaces a validation message and writes nothing.
+  - Saving a default with no threshold set surfaces a validation message.
+  - Saving two rules with the same name in one category surfaces a duplicate-name message.
+  - Deleting a default removes the inherited rule from every item that had not overridden it.
+  - The accessory-category picker lists the owner's existing categories and accepts a category not yet in use.
+  - A signed-out request to the settings action is rejected.
+  - The settings page links to the service-defaults screen, and following that link reaches it.
+- **Verification:** `bun test app` passes and the surface is reachable and operable in `bun run test:e2e`.
+
+### U8. Item detail surfaces
+
+- **Goal:** A firearm or accessory detail view shows its rules with counts, inheritance state, and due state, and offers logging service and reading history.
+- **Requirements:** R5, R11, R14, R17, R18, R21. Cites KTD3, KTD6.
+- **Dependencies:** U4, U6.
+- **Files:**
+  - `app/(app)/firearms/service-rules-panel.tsx` — shared panel for both families.
+  - `app/(app)/firearms/log-service-form.tsx` — the log-service action form.
+  - `app/(app)/firearms/service-rule-form.tsx` — the rule-editing form behind override and add-item-only.
+  - `app/(app)/firearms/service-history.tsx` — history list.
+  - `app/(app)/firearms/firearm-detail-view.tsx` and `app/(app)/accessories/accessory-detail-view.tsx` — mount the panel.
+  - `app/(app)/firearms/service-actions.ts` and `app/(app)/accessories/actions.ts` — server actions.
+- **Approach:**
+  1. One panel component serves both families, taking the resolved rules and counts as props — the derivation already produces one shape for both.
+  2. Each rule shows its thresholds, its elapsed counts, whether it is inherited, overridden, or item-only, and whether it is due. Being past a threshold shows as the raw counts, with no severity tier per R11.
+  3. Override, reset-to-inherited, suppress, restore, and add-item-only are the five rule actions. Override and add-item-only both open `service-rule-form.tsx` — name plus the three threshold fields, with the same validation messages the defaults form surfaces; reset, suppress, and restore need no fields and are direct actions.
+  4. The panel renders read-only for a view-grantee; the log-service action shows for an edit-grantee on a firearm and for the owner only on an accessory, per KTD3.
+  5. Nothing here interrupts, confirms, or blocks — R21 makes this advisory, so a due rule is a marker, never a modal.
+- **Patterns to follow:** `app/(app)/firearms/range-session-history.tsx` and `range-session-form.tsx` for the child-record history-plus-form pair on a detail view; `app/(app)/firearms/mounted-accessories.tsx` for a panel that renders differently by permission.
+- **Test scenarios:**
+  - Covers F2. Logging service against Cleaning on a rifle clears that rule's due state, zeroes its counts, and adds the event to history while leaving the Barrel rule's counts unchanged.
+  - Covers R18. A rule renders its thresholds, its elapsed counts on all three axes, and its inheritance state.
+  - Covers R11. A rule 300 rounds past a 500-round threshold shows 800 rounds and a due marker, with no additional severity treatment.
+  - Covers R5. Overriding a rule marks it overridden; resetting it returns it to inherited.
+  - Suppressing a rule removes it from the panel's active list and offers restoring it.
+  - Adding an item-only rule shows it as item-only and it survives a change to the category defaults.
+  - A view-grantee on a shared firearm sees the panel with no rule actions and no log-service form.
+  - An edit-grantee on a shared firearm sees the log-service form but no rule actions.
+  - An accessory detail view shows rule actions only to the owner.
+  - An item with no rules shows an empty state pointing at the defaults settings surface rather than a blank panel.
+  - The log-service form rejects a future date.
+  - Overriding a rule through the rule form with an empty name or no threshold set surfaces the same validation messages the defaults form uses and writes nothing.
+- **Verification:** `bun test app` passes; `bun run test:e2e` covers the log-service and override paths through ARIA roles and accessible names, with no `data-testid` introduced.
+
+### U9. Roll-up surfaces
+
+- **Goal:** `/summary` carries a service roll-up, and the firearm and accessory lists mark items with at least one due rule.
+- **Requirements:** R19, R20, R21. Cites KTD4.
+- **Dependencies:** U4.
+- **Files:**
+  - `src/domain/summary/summary.ts` — extend `Summary` and `inventorySummary` with the service roll-up.
+  - `app/(app)/summary/summary-tables.tsx` — render it beside the ammo low-stock roll-up.
+  - `app/(app)/firearms/firearms-view.tsx` and `app/(app)/accessories/accessories-view.tsx` — the due indicator.
+  - `src/domain/summary/__tests__/summary.test.ts`
+- **Approach:**
+  1. The roll-up counts items with at least one due rule and due rules in total, so the owner sees both breadth and volume from one line.
+  2. Extend the existing `Summary` shape rather than adding a parallel one — `/summary` already loads the visible inventory once, and the service loaders take the same visible set.
+  3. The list indicator is a marker on the row, not a new column of counts, keeping it advisory per R21. It carries visible text — "Service due" — not color or an icon alone, matching the NFA badge and the summary tables' existing never-color-alone treatment. That text is also what the end-to-end specs target, since the repo forbids `data-testid`.
+- **Patterns to follow:** `computeAmmoRollups` in `src/domain/summary/summary.ts` for a roll-up folded into the existing `Summary`; the ammo low-stock treatment in `app/(app)/summary/summary-tables.tsx` for placement.
+- **Test scenarios:**
+  - Covers AE5. An item suppressing a rule it would otherwise exceed is absent from the roll-up and unmarked in the list.
+  - Covers R19. An owner with three items due across five rules sees both counts.
+  - Covers R20. A firearm with one due rule is marked in the list; one with none is not.
+  - The due marker exposes its state as text, so the row is findable by accessible name without a `data-testid`.
+  - An owner with no defaults configured anywhere sees a zero roll-up, not an empty state error.
+  - A shared firearm that is due appears in the grantee's roll-up using its owner's defaults.
+  - An item that is due only because of an accessory mounted to it does not itself get marked — accessory due state marks the accessory.
+  - The summary loads without a per-item query as the visible set grows.
+- **Verification:** `bun test src/domain/summary app` passes and `/summary` renders both roll-ups.
+
+### U10. Demo seed and end-to-end coverage
+
+- **Goal:** The demo inventory shows the feature, and the settings-to-due-to-logged path is proven end to end.
+- **Requirements:** R3, R4, R14, R18, R19, R20.
+- **Dependencies:** U7, U8, U9.
+- **Files:**
+  - `src/demo/inventory.ts` — seed defaults, a couple of overrides, and some service history.
+  - `e2e/service-intervals.spec.ts` — the full flow.
+  - `e2e/service-intervals-sharing.spec.ts` — the grantee gate.
+- **Approach:** Seed the demo so at least one item is due and at least one is not, and so one override and one suppression are visible — a demo where everything is due proves nothing about the resolution. End-to-end specs target ARIA roles, accessible names, and visible text.
+- **Patterns to follow:** `e2e/range-sessions.spec.ts` and `e2e/inventory-log-sharing.spec.ts` for the feature-plus-sharing spec pair; `e2e/README.md` for the harness; `src/demo/inventory.ts` for seed shape.
+- **Test scenarios:**
+  - Covers F1 and F2. Setting a rifle default from settings marks a rifle due on its list row and in the roll-up; logging service from its detail view clears both.
+  - Covers F3. Overriding one rifle's Barrel rule and then raising the rifle Barrel default leaves the override standing and moves every other rifle.
+  - A view-grantee opening a shared firearm sees rules but no log-service control.
+  - An edit-grantee logs service on a shared firearm and the history names them as actor.
+  - The demo walkthrough renders the service panel with a mix of due and not-due rules.
+  - No route regresses on the responsive-overflow check with the new panel and indicators present.
+- **Verification:** `bun run test:e2e` passes with Docker running.
+
+---
+
+## Verification Contract
+
+| Gate | Command | Applies to |
+|---|---|---|
+| Full pre-commit gate | `just ci-check` | Every commit, mandatory — never bypassed |
+| Lint | `bun run lint` | All units |
+| Format | `bun run format` | All units |
+| Types | `bun run typecheck` | All units |
+| Unit and integration tests | `bun test src` | U1–U6, U9 |
+| Server-action and page tests | `bun test app` | U7–U9 |
+| End-to-end | `bun run test:e2e` | U5, U7–U10 |
+| Migration applies clean | `bun run db:migrate` against a fresh database | U1, U5 |
+| Schema and migration agree | `bun run db:generate` produces no diff | U1, U5 |
+| Timezone robustness | `TZ=Asia/Tokyo bun test src/domain/service-intervals` and `TZ=America/New_York bun test src/domain/service-intervals` | U2 |
+
+Docker is required — integration and end-to-end tests run against Testcontainers-provisioned Postgres, and `src/test-support/preload.ts` provisions it before any test module loads. Never gate a suite on an ambient `DATABASE_URL`. Never run e2e specs through raw `bun test`; they load only under `bun run test:e2e`.
+
+---
+
+## Definition of Done
+
+**Global**
+
+- `just ci-check` passes. No commit lands while it is red, and no check is skipped or bypassed.
+- Every requirement R1–R22 is implemented or explicitly traced to the unit that implements it.
+- Every acceptance example AE1–AE6 has at least one test naming it.
+- The three new tables are registered in `src/backup/table-order.ts` and the backup coverage guard passes.
+- No `data-testid` was introduced; end-to-end selectors use ARIA roles, accessible names, or visible text.
+- The `cleaned` and `lubed` event types are gone from the domain constants, the database CHECK, the log-entry form, and the tests — with every pre-existing entry converted, none lost, and none duplicated.
+- Abandoned or experimental code from approaches that did not pan out is removed from the diff.
+- `CONCEPTS.md` gains entries for Service Rule and Service Event once the terms are real in the codebase.
+
+**Per unit**
+
+| Unit | Done signal |
+|---|---|
+| U1 | Migration applies against a fresh database, constraint tests pass, backup guard green |
+| U2 | Pure tests pass under UTC and two non-UTC timezones |
+| U3 | Authorization tests cover owner, edit-grantee, view-grantee, and no-visibility on both families |
+| U4 | Collection-wide due resolution issues a bounded query count and matches the pure layer's result per item |
+| U5 | Pre- and post-migration row counts reconcile, and no `cleaned` or `lubed` row or option remains |
+| U6 | Acquired date round-trips through create, edit, and clear, and feeds the origin date |
+| U7 | A default set from settings changes due state across the collection with no item visited |
+| U8 | Both detail views render the panel, and the five rule actions plus log-service work with correct permission gating |
+| U9 | Roll-up and list indicators agree with per-item due state |
+| U10 | End-to-end flow green and demo seed shows a mix of due and not-due rules |
diff --git a/e2e/fixtures/user-pool.ts b/e2e/fixtures/user-pool.ts
index 5f387105..86b90cbf 100644
--- a/e2e/fixtures/user-pool.ts
+++ b/e2e/fixtures/user-pool.ts
@@ -43,6 +43,12 @@ export const SPEC_USER_KEYS = [
   "demo-walkthrough",
   "firearm-list-thumbnails",
   "responsive-overflow",
+  "service-intervals",
+  "service-intervals-share",
+  "service-intervals-viewer",
+  "service-intervals-bulk",
+  "service-intervals-bulk-share",
+  "service-intervals-rule-actions",
 ] as const;
 
 export type SpecUserKey = (typeof SPEC_USER_KEYS)[number];
diff --git a/e2e/inventory-log.spec.ts b/e2e/inventory-log.spec.ts
index e37b8b49..4b2df2e5 100644
--- a/e2e/inventory-log.spec.ts
+++ b/e2e/inventory-log.spec.ts
@@ -3,9 +3,12 @@ import { authTest, expect } from "./fixtures/auth";
 
 /**
  * Inventory log (R7-R13), UI layer, single-user. Covers R9 (newest-first),
- * R10 ("Mark inventoried"), R11 ("Log…" form incl. per-parent event-type set),
- * and R12 (ARIA targeting, no data-testid) through the real browser on one
- * seeded "inventory-log" user. Sharing/actor-attribution (R7/R8) is covered in
+ * R10 ("Mark inventoried"), R11 ("Log…" form's event-type select, which now
+ * offers only "inventoried" for either parent family — the service-intervals
+ * plan's U5 retired `cleaned`/`lubed` as firearm event types (R13), converting
+ * every prior entry to a `service_event`), and R12 (ARIA targeting, no
+ * data-testid) through the real browser on one seeded "inventory-log" user.
+ * Sharing/actor-attribution (R7/R8) is covered in
  * `inventory-log-sharing.spec.ts`; cascade deletion (R13) is proven at the
  * integration layer in `src/domain/inventory-log/__tests__/service.test.ts` and
  * need not be re-proven here. One sequential test on a fresh user; each step
@@ -34,7 +37,7 @@ function logTable(page: Page) {
  */
 const NINE_OCLOCK_LOCAL = /\b0?9:00\b/;
 
-test("logs, orders newest-first, and gates event types per parent", async ({
+test("logs, orders newest-first, and offers only 'inventoried' for both parents (U5)", async ({
   page,
 }) => {
   await test.step("create a firearm and open its detail page", async () => {
@@ -66,36 +69,47 @@ test("logs, orders newest-first, and gates event types per parent", async ({
     await expect(rows.first()).toContainText("inventory-log");
   });
 
-  await test.step("Log… records a backdated maintenance entry above an older one (R9/R11)", async () => {
+  await test.step("a firearm's event-type select offers only 'inventoried' (R11/R13 — cleaned/lubed retired, U5)", async () => {
+    await page.getByRole("button", { name: "Log…" }).click();
+    const form = page.locator("form").last();
+    const eventSelect = form.getByLabel("Event type");
+    await expect(eventSelect.locator("option")).toHaveCount(1);
+    await expect(eventSelect.locator("option").first()).toHaveText(
+      "Inventoried",
+    );
+    await form.getByRole("button", { name: "Cancel" }).click();
+  });
+
+  await test.step("Log… records backdated entries above an older one, newest-first (R9)", async () => {
     await page.getByRole("button", { name: "Log…" }).click();
     let form = page.locator("form").last();
-    await form.getByLabel("Event type").selectOption("lubed");
+    await form.getByLabel("Event type").selectOption("inventoried");
     await form.getByLabel("Date & time").fill("2026-01-15T09:00");
-    await form.getByLabel("Notes").fill("First scheduled lube");
+    await form.getByLabel("Notes").fill("First scheduled check");
     await form.getByRole("button", { name: "Log" }).click();
     await expect(page.getByText("Logged").first()).toBeVisible();
 
     await page.getByRole("button", { name: "Log…" }).click();
     form = page.locator("form").last();
-    await form.getByLabel("Event type").selectOption("cleaned");
+    await form.getByLabel("Event type").selectOption("inventoried");
     await form.getByLabel("Date & time").fill("2026-03-01T09:00");
-    await form.getByLabel("Notes").fill("Field strip and clean");
+    await form.getByLabel("Notes").fill("Second scheduled check");
     await form.getByRole("button", { name: "Log" }).click();
     await expect(page.getByText("Logged").first()).toBeVisible();
 
     // Newest-first (R9): the just-marked "now" entry stays on top, the more
-    // recently-dated "cleaned" entry sorts above the older "lubed" entry, and
-    // the maintenance type + notes render for it.
+    // recently-dated backdated entry sorts above the older one, and its notes
+    // render alongside it.
     const rows = logTable(page).locator("tbody tr");
     await expect(rows).toHaveCount(3);
     await expect(rows.nth(0)).toContainText("Inventoried");
-    await expect(rows.nth(1)).toContainText("Cleaned");
-    await expect(rows.nth(1)).toContainText("Field strip and clean");
+    await expect(rows.nth(1)).toContainText("Inventoried");
+    await expect(rows.nth(1)).toContainText("Second scheduled check");
     // The entered "2026-03-01T09:00" local wall-clock time must render as
     // 9:00, not shifted by a doubled-offset / local-as-UTC bug (R9).
     await expect(rows.nth(1)).toContainText(NINE_OCLOCK_LOCAL);
-    await expect(rows.nth(2)).toContainText("Lubed");
-    await expect(rows.nth(2)).toContainText("First scheduled lube");
+    await expect(rows.nth(2)).toContainText("Inventoried");
+    await expect(rows.nth(2)).toContainText("First scheduled check");
   });
 
   await test.step("a magazine only offers the 'inventoried' event type (R11)", async () => {
diff --git a/e2e/service-intervals-bulk-sharing.spec.ts b/e2e/service-intervals-bulk-sharing.spec.ts
new file mode 100644
index 00000000..d93320a5
--- /dev/null
+++ b/e2e/service-intervals-bulk-sharing.spec.ts
@@ -0,0 +1,163 @@
+import { isoDateDaysAgo } from "@/src/demo/inventory";
+import {
+  authTest,
+  expect,
+  readArtifact,
+  storageStateFor,
+} from "./fixtures/auth";
+
+/**
+ * Regression coverage for the code-review finding: a view-only grantee's
+ * `/summary` bulk mark-serviced checklist must never offer a row for an item
+ * they cannot log service on (KTD3). `listDueForVisibleCollection` legitimately
+ * includes a shared firearm at every visibility tier — the roll-up counts are
+ * information, not an action, and stay unchanged (`service-intervals-bulk.spec.ts`
+ * covers the roll-up/owner path) — but `logServiceEventsBulk` only ever
+ * authorizes an owner or edit-grantee, never a view-only one. Before the fix,
+ * a view-grantee saw the shared firearm's due rule as a selectable checkbox
+ * that would throw (and roll back the whole batch) if checked and submitted.
+ *
+ * Distinct owner user from `service-intervals-bulk` (that spec's account has
+ * its own, unrelated due backlog) sharing into the existing
+ * `service-intervals-viewer` grantee (already used as a grantee elsewhere,
+ * carries no firearms of its own).
+ */
+const test = authTest("service-intervals-bulk-share");
+
+// Stateful, no cleanup: a retry would start from a dirty account.
+test.describe.configure({ retries: 0 });
+
+test("a view-only grantee's bulk backlog excludes the shared firearm; an edit-grantee's includes and can act on it", async ({
+  page,
+  browser,
+}) => {
+  const grantee = readArtifact().users.find(
+    (u) => u.key === "service-intervals-viewer",
+  );
+  if (!grantee) throw new Error("service-intervals-viewer not seeded");
+
+  await test.step("owner creates two rifles, both well past a week old", async () => {
+    await page.goto("/firearms");
+    await page.getByRole("button", { name: "Add your first firearm" }).click();
+    let form = page.locator("form");
+    await form.getByLabel(/^Name/).fill("Bulk Share Edit Rifle");
+    await form.getByLabel("Caliber").fill("5.56");
+    await form.getByLabel(/^Type/).selectOption("rifle");
+    await form.getByLabel("Action").selectOption("semi-auto");
+    await form.getByLabel("Acquired date").fill(isoDateDaysAgo(30));
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    await expect(page.getByText("Firearm logged").first()).toBeVisible();
+
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    form = page.locator("form");
+    await form.getByLabel(/^Name/).fill("Bulk Share View Rifle");
+    await form.getByLabel("Caliber").fill("5.56");
+    await form.getByLabel(/^Type/).selectOption("rifle");
+    await form.getByLabel("Action").selectOption("semi-auto");
+    await form.getByLabel("Acquired date").fill(isoDateDaysAgo(30));
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    await expect(page.getByText("Firearm logged").last()).toBeVisible();
+  });
+
+  await test.step("owner arms the Rifle category with a 7-day Cleaning rule — both rifles become due", async () => {
+    await page.goto("/settings/service");
+    const rifleSection = page.getByRole("region", { name: "Rifle" });
+    await rifleSection.getByRole("button", { name: "Add rule" }).click();
+    const form = rifleSection.locator("form");
+    await form.getByLabel("Rule name").fill("Cleaning");
+    await form.getByLabel("Days").fill("7");
+    await form.getByRole("button", { name: "Add rule" }).click();
+    await expect(page.getByText("Rifle rule added")).toBeVisible();
+  });
+
+  await test.step("owner shares one rifle at edit and the other at view", async () => {
+    await page.goto("/firearms");
+    await page
+      .getByRole("row")
+      .filter({ hasText: "Bulk Share Edit Rifle" })
+      .getByRole("button", { name: "Share" })
+      .click();
+    let dialog = page.getByRole("dialog");
+    await dialog.getByLabel("User").selectOption({ label: grantee.email });
+    await dialog.getByLabel("Permission").selectOption("edit");
+    await dialog.getByRole("button", { name: "Share" }).click();
+    await expect(
+      dialog.getByRole("listitem").filter({ hasText: grantee.email }),
+    ).toBeVisible();
+    await dialog.getByRole("button", { name: "Done" }).click();
+
+    await page
+      .getByRole("row")
+      .filter({ hasText: "Bulk Share View Rifle" })
+      .getByRole("button", { name: "Share" })
+      .click();
+    dialog = page.getByRole("dialog");
+    await dialog.getByLabel("User").selectOption({ label: grantee.email });
+    // Permission defaults to "view".
+    await dialog.getByRole("button", { name: "Share" }).click();
+    await expect(
+      dialog.getByRole("listitem").filter({ hasText: grantee.email }),
+    ).toBeVisible();
+    await dialog.getByRole("button", { name: "Done" }).click();
+  });
+
+  await test.step("the owner's own bulk backlog still offers both shared rifles (owner permission on both)", async () => {
+    await page.goto("/summary");
+    const control = page.getByRole("region", { name: "Mark service due" });
+    await expect(
+      control.getByRole("checkbox", {
+        name: "Bulk Share Edit Rifle — Cleaning",
+      }),
+    ).toBeVisible();
+    await expect(
+      control.getByRole("checkbox", {
+        name: "Bulk Share View Rifle — Cleaning",
+      }),
+    ).toBeVisible();
+  });
+
+  await test.step("the grantee's bulk backlog offers the edit-shared rifle but never the view-only one", async () => {
+    const granteeContext = await browser.newContext({
+      storageState: storageStateFor("service-intervals-viewer"),
+    });
+    try {
+      const gp = await granteeContext.newPage();
+      await gp.goto("/summary");
+      const control = gp.getByRole("region", { name: "Mark service due" });
+
+      // The roll-up is informational and legitimately includes BOTH shared
+      // firearms' due state (KTD3) — unchanged by this fix. Only the
+      // ACTIONABLE checklist below narrows to what the grantee can log.
+      await expect(
+        gp.getByText(/items due for service across \d+ rules/),
+      ).toBeVisible();
+
+      await expect(
+        control.getByRole("checkbox", {
+          name: "Bulk Share Edit Rifle — Cleaning",
+        }),
+      ).toBeVisible();
+      await expect(
+        control.getByRole("checkbox", {
+          name: "Bulk Share View Rifle — Cleaning",
+        }),
+      ).toHaveCount(0);
+
+      await control
+        .getByRole("checkbox", { name: "Bulk Share Edit Rifle — Cleaning" })
+        .click();
+      await control.getByRole("button", { name: "Mark serviced" }).click();
+      await expect(gp.getByText("Marked 1 rule serviced")).toBeVisible();
+
+      // Confirms the offered row was genuinely actionable, not merely absent
+      // from the exclusion — it cleared after being marked serviced.
+      await expect(
+        control.getByRole("checkbox", {
+          name: "Bulk Share Edit Rifle — Cleaning",
+        }),
+      ).toHaveCount(0);
+    } finally {
+      await granteeContext.close();
+    }
+  });
+});
diff --git a/e2e/service-intervals-bulk.spec.ts b/e2e/service-intervals-bulk.spec.ts
new file mode 100644
index 00000000..30f95461
--- /dev/null
+++ b/e2e/service-intervals-bulk.spec.ts
@@ -0,0 +1,114 @@
+import { isoDateDaysAgo } from "@/src/demo/inventory";
+import { authTest, expect } from "./fixtures/auth";
+
+/**
+ * The R16 bulk mark-serviced surface: "An owner can mark one or many items
+ * serviced as of a date in a single action, so the day-one backlog clears
+ * without visiting each item." Before this spec, `logServiceEventsBulk`
+ * existed and was integration-tested but had NO app surface — this proves
+ * the Done signal end to end: an owner with several due items marks them
+ * all serviced in one action from `/summary`, and the roll-up and the list
+ * markers both clear afterward.
+ *
+ * A dedicated user (`service-intervals-bulk`), distinct from
+ * `service-intervals`/`service-intervals-share`/`service-intervals-viewer` —
+ * those specs are already stateful and sequential; this one needs its own
+ * clean backlog to select against.
+ */
+const test = authTest("service-intervals-bulk");
+
+// Stateful, no cleanup: a retry would start from a dirty account.
+test.describe.configure({ retries: 0 });
+
+test("an owner with several due items marks them all serviced in one action from /summary, clearing the roll-up and every list marker", async ({
+  page,
+}) => {
+  await test.step("owner creates two rifles, both well past a week old", async () => {
+    await page.goto("/firearms");
+    await page.getByRole("button", { name: "Add your first firearm" }).click();
+    let form = page.locator("form");
+    await form.getByLabel(/^Name/).fill("Bulk Rifle One");
+    await form.getByLabel("Caliber").fill("5.56");
+    await form.getByLabel(/^Type/).selectOption("rifle");
+    await form.getByLabel("Action").selectOption("semi-auto");
+    await form.getByLabel("Acquired date").fill(isoDateDaysAgo(30));
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    await expect(page.getByText("Firearm logged").first()).toBeVisible();
+
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    form = page.locator("form");
+    await form.getByLabel(/^Name/).fill("Bulk Rifle Two");
+    await form.getByLabel("Caliber").fill("5.56");
+    await form.getByLabel(/^Type/).selectOption("rifle");
+    await form.getByLabel("Action").selectOption("semi-auto");
+    await form.getByLabel("Acquired date").fill(isoDateDaysAgo(30));
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    await expect(page.getByText("Firearm logged").last()).toBeVisible();
+  });
+
+  await test.step("owner arms the Rifle category with a 7-day Cleaning rule — both rifles become due", async () => {
+    await page.goto("/settings/service");
+    const rifleSection = page.getByRole("region", { name: "Rifle" });
+    await rifleSection.getByRole("button", { name: "Add rule" }).click();
+    const form = rifleSection.locator("form");
+    await form.getByLabel("Rule name").fill("Cleaning");
+    await form.getByLabel("Days").fill("7");
+    await form.getByRole("button", { name: "Add rule" }).click();
+    await expect(page.getByText("Rifle rule added")).toBeVisible();
+
+    await page.goto("/firearms");
+    await expect(page.getByText("Service due")).toHaveCount(2);
+  });
+
+  await test.step("the /summary roll-up counts both due items and offers the bulk mark-serviced control", async () => {
+    await page.goto("/summary");
+    await expect(
+      page.getByText("2 items due for service across 2 rules"),
+    ).toBeVisible();
+
+    const control = page.getByRole("region", { name: "Mark service due" });
+    await expect(
+      control.getByRole("checkbox", {
+        name: "Bulk Rifle One — Cleaning",
+      }),
+    ).toBeVisible();
+    await expect(
+      control.getByRole("checkbox", {
+        name: "Bulk Rifle Two — Cleaning",
+      }),
+    ).toBeVisible();
+
+    // R21/safe-default: nothing starts checked, and the submit control is
+    // disabled until the owner opts in.
+    await expect(
+      control.getByRole("checkbox", { name: "Select all" }),
+    ).not.toBeChecked();
+    await expect(
+      control.getByRole("button", { name: "Mark serviced" }),
+    ).toBeDisabled();
+  });
+
+  await test.step("owner selects all, keeps today's date, and marks both serviced in one action (R16)", async () => {
+    const control = page.getByRole("region", { name: "Mark service due" });
+    await control.getByRole("checkbox", { name: "Select all" }).click();
+    await expect(control.getByText("2 selected")).toBeVisible();
+    await control.getByRole("button", { name: "Mark serviced" }).click();
+    await expect(page.getByText("Marked 2 rules serviced")).toBeVisible();
+  });
+
+  await test.step("the roll-up and every list marker clear afterward (Done signal)", async () => {
+    await expect(
+      page.getByText("0 items due for service across 0 rules"),
+    ).toBeVisible();
+
+    await page.goto("/firearms");
+    await expect(page.getByText("Service due")).toHaveCount(0);
+  });
+
+  await test.step("the service history on each rifle now names the bulk-logged event", async () => {
+    await page.goto("/firearms");
+    await page.getByRole("link", { name: "Bulk Rifle One" }).click();
+    const history = page.getByRole("region", { name: "Service history" });
+    await expect(history).toContainText("Cleaning");
+  });
+});
diff --git a/e2e/service-intervals-rule-actions.spec.ts b/e2e/service-intervals-rule-actions.spec.ts
new file mode 100644
index 00000000..76067e65
--- /dev/null
+++ b/e2e/service-intervals-rule-actions.spec.ts
@@ -0,0 +1,143 @@
+import { authTest, expect } from "./fixtures/auth";
+
+/**
+ * Regression coverage for the code-review finding: "Suppress" on an
+ * item-only rule silently destroyed its thresholds with no honest path back
+ * (KTD6's exactly-one-of-thresholds-or-suppressed CHECK forces a suppressed
+ * row's thresholds to null, and "Restore" only ever deletes the row — there
+ * is no default underneath an item-only rule for that deletion to fall back
+ * to). The fix: an item-only rule now offers "Remove" (delete the row
+ * outright, with a toast that says so) instead of "Suppress". `inherited`
+ * and `overridden` rules keep "Suppress" exactly as before — this spec
+ * proves both halves: the new item-only affordance, and that the
+ * pre-existing inherited/overridden suppress-then-restore cycle is
+ * untouched.
+ */
+const test = authTest("service-intervals-rule-actions");
+
+// Stateful, no cleanup: a retry would start from a dirty account.
+test.describe.configure({ retries: 0 });
+
+test("an item-only rule offers Remove (not Suppress) and deletes on click; inherited/overridden rules keep Suppress unchanged", async ({
+  page,
+}) => {
+  await test.step("owner creates a rifle", async () => {
+    await page.goto("/firearms");
+    await page.getByRole("button", { name: "Add your first firearm" }).click();
+    const form = page.locator("form");
+    await form.getByLabel(/^Name/).fill("Rule Actions Rifle");
+    await form.getByLabel("Caliber").fill("5.56");
+    await form.getByLabel(/^Type/).selectOption("rifle");
+    await form.getByLabel("Action").selectOption("semi-auto");
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    await expect(page.getByText("Firearm logged").first()).toBeVisible();
+    await page.getByRole("link", { name: "Rule Actions Rifle" }).click();
+  });
+
+  await test.step("an item-only rule offers Remove, never Suppress or Override", async () => {
+    await page.getByRole("button", { name: "Add item-only rule" }).click();
+    const addForm = page.locator("form");
+    await addForm.getByLabel("Rule name").fill("Recoil spring");
+    await addForm.getByLabel("Days").fill("90");
+    await addForm.getByRole("button", { name: "Add rule" }).click();
+    await expect(page.getByText("Item-only rule added")).toBeVisible();
+
+    const panel = page.getByRole("region", { name: "Service rules" });
+    await expect(
+      panel.getByRole("row").filter({ hasText: "Recoil spring" }),
+    ).toBeVisible();
+    await expect(
+      page.getByRole("button", { name: "Remove Recoil spring" }),
+    ).toBeVisible();
+    await expect(
+      page.getByRole("button", { name: "Suppress Recoil spring" }),
+    ).toHaveCount(0);
+    await expect(
+      page.getByRole("button", { name: "Override Recoil spring" }),
+    ).toHaveCount(0);
+  });
+
+  await test.step("Remove deletes the item-only rule outright — it never lands in Suppressed rules", async () => {
+    await page.getByRole("button", { name: "Remove Recoil spring" }).click();
+    await expect(page.getByText("Recoil spring removed")).toBeVisible();
+
+    const panel = page.getByRole("region", { name: "Service rules" });
+    await expect(
+      panel.getByRole("row").filter({ hasText: "Recoil spring" }),
+    ).toHaveCount(0);
+    await expect(
+      page.getByRole("button", { name: "Restore Recoil spring" }),
+    ).toHaveCount(0);
+  });
+
+  await test.step("owner arms the Rifle category with a Cleaning default — the rifle inherits it", async () => {
+    await page.goto("/settings/service");
+    const rifleSection = page.getByRole("region", { name: "Rifle" });
+    await rifleSection.getByRole("button", { name: "Add rule" }).click();
+    const form = rifleSection.locator("form");
+    await form.getByLabel("Rule name").fill("Cleaning");
+    await form.getByLabel("Days").fill("180");
+    await form.getByRole("button", { name: "Add rule" }).click();
+    await expect(page.getByText("Rifle rule added")).toBeVisible();
+
+    await page.goto("/firearms");
+    await page.getByRole("link", { name: "Rule Actions Rifle" }).click();
+  });
+
+  await test.step("the inherited Cleaning rule offers Suppress (unchanged) — not Remove", async () => {
+    await expect(
+      page.getByRole("button", { name: "Suppress Cleaning" }),
+    ).toBeVisible();
+    await expect(
+      page.getByRole("button", { name: "Remove Cleaning" }),
+    ).toHaveCount(0);
+    await expect(
+      page.getByRole("button", { name: "Reset Cleaning to inherited" }),
+    ).toHaveCount(0);
+  });
+
+  await test.step("overriding Cleaning keeps Suppress (not Remove) and adds Reset to inherited", async () => {
+    await page.getByRole("button", { name: "Override Cleaning" }).click();
+    const overrideForm = page.locator("form");
+    await overrideForm.getByLabel("Days").fill("30");
+    await overrideForm.getByRole("button", { name: "Save override" }).click();
+    await expect(page.getByText("Cleaning updated")).toBeVisible();
+
+    await expect(
+      page.getByRole("button", { name: "Reset Cleaning to inherited" }),
+    ).toBeVisible();
+    await expect(
+      page.getByRole("button", { name: "Suppress Cleaning" }),
+    ).toBeVisible();
+    await expect(
+      page.getByRole("button", { name: "Remove Cleaning" }),
+    ).toHaveCount(0);
+
+    await page
+      .getByRole("button", { name: "Reset Cleaning to inherited" })
+      .click();
+    await expect(page.getByText("Cleaning reset to inherited")).toBeVisible();
+  });
+
+  await test.step("suppressing then restoring the inherited Cleaning rule still behaves exactly as before", async () => {
+    await page.getByRole("button", { name: "Suppress Cleaning" }).click();
+    await expect(page.getByText("Cleaning suppressed")).toBeVisible();
+
+    const panel = page.getByRole("region", { name: "Service rules" });
+    await expect(
+      panel.getByRole("row").filter({ hasText: "Cleaning" }),
+    ).toHaveCount(0);
+    await expect(
+      page.getByRole("button", { name: "Restore Cleaning" }),
+    ).toBeVisible();
+
+    await page.getByRole("button", { name: "Restore Cleaning" }).click();
+    await expect(page.getByText("Cleaning restored")).toBeVisible();
+    await expect(
+      panel.getByRole("row").filter({ hasText: "Cleaning" }),
+    ).toBeVisible();
+    await expect(
+      page.getByRole("button", { name: "Suppress Cleaning" }),
+    ).toBeVisible();
+  });
+});
diff --git a/e2e/service-intervals-sharing.spec.ts b/e2e/service-intervals-sharing.spec.ts
new file mode 100644
index 00000000..870d33ed
--- /dev/null
+++ b/e2e/service-intervals-sharing.spec.ts
@@ -0,0 +1,217 @@
+import {
+  authTest,
+  expect,
+  readArtifact,
+  storageStateFor,
+} from "./fixtures/auth";
+
+/**
+ * Service interval tracking (issue #10), the KTD3 permission gate — the same
+ * shape as `inventory-log-sharing.spec.ts` and `range-sessions-sharing.spec.ts`:
+ * the default `authTest` context owns and shares two firearms plus one
+ * mounted accessory; a second browser context carries the grantee's session.
+ *
+ * KTD3: an edit-grantee on a firearm may log service but never configure
+ * rules; a view-grantee gets neither; accessories are owner-only throughout,
+ * so a firearm grantee's inherited accessory access never extends to that
+ * accessory's OWN service configuration or history, however much of the rest
+ * of the accessory record they can see. Each firearm carries one item-only
+ * rule (added by the owner) so a grantee has something to observe — due
+ * state itself is out of scope here (that's `service-intervals.spec.ts`).
+ */
+const test = authTest("service-intervals-share");
+
+// Stateful, no cleanup: a retry would start from a dirty account.
+test.describe.configure({ retries: 0 });
+
+test("an edit-grantee logs service but gets no rule actions; a view-grantee gets neither; accessory service stays owner-only", async ({
+  page,
+  browser,
+}) => {
+  const grantee = readArtifact().users.find(
+    (u) => u.key === "service-intervals-viewer",
+  );
+  if (!grantee) throw new Error("service-intervals-viewer not seeded");
+
+  await test.step("owner creates two rifles, each with an item-only Cleaning rule", async () => {
+    await page.goto("/firearms");
+    await page.getByRole("button", { name: "Add your first firearm" }).click();
+    let form = page.locator("form");
+    await form.getByLabel(/^Name/).fill("Grantee Edit Rifle");
+    await form.getByLabel("Caliber").fill("5.56");
+    await form.getByLabel(/^Type/).selectOption("rifle");
+    await form.getByLabel("Action").selectOption("semi-auto");
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    await expect(page.getByText("Firearm logged").first()).toBeVisible();
+
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    form = page.locator("form");
+    await form.getByLabel(/^Name/).fill("Grantee View Rifle");
+    await form.getByLabel("Caliber").fill("5.56");
+    await form.getByLabel(/^Type/).selectOption("rifle");
+    await form.getByLabel("Action").selectOption("semi-auto");
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    await expect(page.getByText("Firearm logged").last()).toBeVisible();
+
+    for (const name of ["Grantee Edit Rifle", "Grantee View Rifle"]) {
+      await page.goto("/firearms");
+      await page.getByRole("link", { name }).click();
+      await page.getByRole("button", { name: "Add item-only rule" }).click();
+      const ruleForm = page
+        .getByRole("region", { name: "Service rules" })
+        .locator("form");
+      await ruleForm.getByLabel("Rule name").fill("Cleaning");
+      await ruleForm.getByLabel("Days").fill("1");
+      await ruleForm.getByRole("button", { name: "Add rule" }).click();
+      await expect(page.getByText("Item-only rule added")).toBeVisible();
+    }
+  });
+
+  await test.step("owner mounts an accessory on the edit-shared firearm", async () => {
+    await page.goto("/accessories");
+    await page
+      .getByRole("button", { name: "Add your first accessory" })
+      .click();
+    const form = page.locator("form");
+    await form.getByLabel("Category").fill("Optic");
+    await form.getByLabel("Model").fill("Shared Optic");
+    await form
+      .getByLabel("Mount on firearm")
+      .selectOption({ label: "Grantee Edit Rifle" });
+    await page.getByRole("button", { name: "Add accessory" }).click();
+    await expect(page.getByText("Accessory logged").first()).toBeVisible();
+  });
+
+  await test.step("owner shares Grantee Edit Rifle at edit and Grantee View Rifle at view", async () => {
+    await page.goto("/firearms");
+    await page
+      .getByRole("row")
+      .filter({ hasText: "Grantee Edit Rifle" })
+      .getByRole("button", { name: "Share" })
+      .click();
+    let dialog = page.getByRole("dialog");
+    await dialog.getByLabel("User").selectOption({ label: grantee.email });
+    await dialog.getByLabel("Permission").selectOption("edit");
+    await dialog.getByRole("button", { name: "Share" }).click();
+    await expect(
+      dialog.getByRole("listitem").filter({ hasText: grantee.email }),
+    ).toBeVisible();
+    await dialog.getByRole("button", { name: "Done" }).click();
+
+    await page
+      .getByRole("row")
+      .filter({ hasText: "Grantee View Rifle" })
+      .getByRole("button", { name: "Share" })
+      .click();
+    dialog = page.getByRole("dialog");
+    await dialog.getByLabel("User").selectOption({ label: grantee.email });
+    // Permission defaults to "view".
+    await dialog.getByRole("button", { name: "Share" }).click();
+    await expect(
+      dialog.getByRole("listitem").filter({ hasText: grantee.email }),
+    ).toBeVisible();
+    await dialog.getByRole("button", { name: "Done" }).click();
+  });
+
+  await test.step("the edit-grantee logs service but sees no rule-management actions", async () => {
+    const granteeContext = await browser.newContext({
+      storageState: storageStateFor("service-intervals-viewer"),
+    });
+    try {
+      const gp = await granteeContext.newPage();
+      await gp.goto("/firearms");
+      await gp.getByRole("link", { name: "Grantee Edit Rifle" }).click();
+
+      const panel = gp.getByRole("region", { name: "Service rules" });
+      await expect(
+        panel.getByRole("row").filter({ hasText: "Cleaning" }),
+      ).toBeVisible();
+      await expect(
+        gp.getByRole("button", { name: "Log service — Cleaning" }),
+      ).toBeVisible();
+      await expect(
+        gp.getByRole("button", { name: "Override Cleaning" }),
+      ).toHaveCount(0);
+      await expect(
+        gp.getByRole("button", { name: "Suppress Cleaning" }),
+      ).toHaveCount(0);
+      await expect(
+        gp.getByRole("button", { name: "Add item-only rule" }),
+      ).toHaveCount(0);
+
+      await gp.getByRole("button", { name: "Log service — Cleaning" }).click();
+      const form = gp.getByRole("form", { name: "Log service — Cleaning" });
+      await form.getByLabel("Notes").fill("Serviced by the edit grantee.");
+      await form.getByRole("button", { name: "Log service" }).click();
+      await expect(gp.getByText("Logged service — Cleaning")).toBeVisible();
+
+      // The history names the ACTING grantee, not the owner (mirrors R7's
+      // inventory-log actor rule, carried into service events by KTD3).
+      const history = gp.getByRole("region", { name: "Service history" });
+      await expect(history).toContainText("Cleaning");
+      // The display name, not the email — `withActorNames` deliberately
+      // resolves `name` so a view-grantee reading a shared firearm's history
+      // never sees another account's address.
+      await expect(history).toContainText(grantee.key);
+    } finally {
+      await granteeContext.close();
+    }
+  });
+
+  await test.step("the view-grantee sees the rule but no log-service control and no rule actions", async () => {
+    const granteeContext = await browser.newContext({
+      storageState: storageStateFor("service-intervals-viewer"),
+    });
+    try {
+      const gp = await granteeContext.newPage();
+      await gp.goto("/firearms");
+      await gp.getByRole("link", { name: "Grantee View Rifle" }).click();
+
+      const panel = gp.getByRole("region", { name: "Service rules" });
+      await expect(
+        panel.getByRole("row").filter({ hasText: "Cleaning" }),
+      ).toBeVisible();
+      await expect(
+        gp.getByRole("button", { name: "Log service — Cleaning" }),
+      ).toHaveCount(0);
+      await expect(
+        gp.getByRole("button", { name: "Override Cleaning" }),
+      ).toHaveCount(0);
+      await expect(
+        gp.getByRole("button", { name: "Suppress Cleaning" }),
+      ).toHaveCount(0);
+      await expect(
+        gp.getByRole("button", { name: "Add item-only rule" }),
+      ).toHaveCount(0);
+    } finally {
+      await granteeContext.close();
+    }
+  });
+
+  await test.step("accessory service configuration never reaches the firearm's grantee, mounted or not", async () => {
+    const granteeContext = await browser.newContext({
+      storageState: storageStateFor("service-intervals-viewer"),
+    });
+    try {
+      const gp = await granteeContext.newPage();
+      await gp.goto("/firearms");
+      await gp.getByRole("link", { name: "Grantee Edit Rifle" }).click();
+      // The mounted accessory is visible (inherited edit permission) — reach
+      // its own detail page via that inheritance, the exact path that would
+      // leak service configuration if KTD3's accessory gate had a hole.
+      await gp.getByRole("link", { name: "Shared Optic" }).click();
+      await expect(
+        gp.getByRole("heading", { level: 1, name: "Shared Optic" }),
+      ).toBeVisible();
+
+      await expect(
+        gp.getByRole("region", { name: "Service rules" }),
+      ).toHaveCount(0);
+      await expect(
+        gp.getByRole("region", { name: "Service history" }),
+      ).toHaveCount(0);
+    } finally {
+      await granteeContext.close();
+    }
+  });
+});
diff --git a/e2e/service-intervals.spec.ts b/e2e/service-intervals.spec.ts
new file mode 100644
index 00000000..30187a8a
--- /dev/null
+++ b/e2e/service-intervals.spec.ts
@@ -0,0 +1,231 @@
+import { isoDateDaysAgo } from "@/src/demo/inventory";
+import { authTest, expect } from "./fixtures/auth";
+
+/**
+ * Service interval tracking (issue #10), full flow — the settings-to-due-to-
+ * logged path the plan's Definition of Done names for U7 explicitly: a
+ * default set from settings changes due state across the collection with no
+ * item visited (F1), and logging service from the item's detail view clears
+ * it again (F2). A second rifle exercises F3/AE1 — overriding one rule keeps
+ * it standing after the category default it diverged from later changes.
+ *
+ * One sequential test on a fresh "service-intervals" user; each step builds
+ * on the last (mirrors accessories.spec.ts / inventory-log-sharing.spec.ts).
+ * `isoDateDaysAgo` is the same local-frame helper the demo seed uses
+ * (`src/demo/inventory.ts`), reused here so the fixture dates stay relative
+ * to "now" rather than drifting stale. ARIA roles, accessible names, and
+ * visible text only — no `data-testid`. The grantee-permission gate (KTD3)
+ * is covered separately in `service-intervals-sharing.spec.ts`.
+ */
+const test = authTest("service-intervals");
+
+// Stateful, no cleanup: a retry would start from a dirty account.
+test.describe.configure({ retries: 0 });
+
+test("a rifle default marks items due with no visit, logging service clears it, and an override survives a later default change", async ({
+  page,
+}) => {
+  await test.step("owner creates two rifles with different acquired dates", async () => {
+    await page.goto("/firearms");
+    await page.getByRole("button", { name: "Add your first firearm" }).click();
+    let form = page.locator("form");
+    await form.getByLabel(/^Name/).fill("Interval Rifle One");
+    await form.getByLabel("Caliber").fill("5.56");
+    await form.getByLabel(/^Type/).selectOption("rifle");
+    await form.getByLabel("Action").selectOption("semi-auto");
+    // Well past any threshold below (KTD9: origin date, no service point yet).
+    await form.getByLabel("Acquired date").fill(isoDateDaysAgo(30));
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    await expect(page.getByText("Firearm logged").first()).toBeVisible();
+
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    form = page.locator("form");
+    await form.getByLabel(/^Name/).fill("Interval Rifle Two");
+    await form.getByLabel("Caliber").fill("5.56");
+    await form.getByLabel(/^Type/).selectOption("rifle");
+    await form.getByLabel("Action").selectOption("semi-auto");
+    // Barely acquired — under the Cleaning default below, over the Barrel
+    // override applied to it later.
+    await form.getByLabel("Acquired date").fill(isoDateDaysAgo(2));
+    await page.getByRole("button", { name: "Add firearm" }).click();
+    await expect(page.getByText("Firearm logged").last()).toBeVisible();
+  });
+
+  await test.step("no rifle is marked due before any default exists", async () => {
+    await page.goto("/firearms");
+    await expect(page.getByText("Service due")).toHaveCount(0);
+  });
+
+  await test.step("owner arms the Rifle category from settings — no item visited (F1)", async () => {
+    await page.goto("/settings");
+    await page
+      .getByRole("link", { name: "Manage service-interval defaults" })
+      .click();
+    await expect(page).toHaveURL(/\/settings\/service$/);
+
+    const rifleSection = page.getByRole("region", { name: "Rifle" });
+
+    await rifleSection.getByRole("button", { name: "Add rule" }).click();
+    let form = rifleSection.locator("form");
+    await form.getByLabel("Rule name").fill("Cleaning");
+    await form.getByLabel("Days").fill("7");
+    await form.getByRole("button", { name: "Add rule" }).click();
+    await expect(page.getByText("Rifle rule added").first()).toBeVisible();
+
+    await rifleSection.getByRole("button", { name: "Add rule" }).click();
+    form = rifleSection.locator("form");
+    await form.getByLabel("Rule name").fill("Barrel");
+    await form.getByLabel("Days").fill("400");
+    await form.getByRole("button", { name: "Add rule" }).click();
+    await expect(page.getByText("Rifle rule added").last()).toBeVisible();
+  });
+
+  await test.step("Interval Rifle One is marked due on its list row; Interval Rifle Two is not (F1, R20)", async () => {
+    await page.goto("/firearms");
+    await expect(
+      page
+        .getByRole("row")
+        .filter({ hasText: "Interval Rifle One" })
+        .getByText("Service due"),
+    ).toBeVisible();
+    await expect(
+      page
+        .getByRole("row")
+        .filter({ hasText: "Interval Rifle Two" })
+        .getByText("Service due"),
+    ).toHaveCount(0);
+  });
+
+  await test.step("the /summary roll-up counts the one due item and rule (R19)", async () => {
+    await page.goto("/summary");
+    await expect(
+      page.getByText("1 item due for service across 1 rule"),
+    ).toBeVisible();
+  });
+
+  await test.step("Interval Rifle One's panel shows a mix — Cleaning due, Barrel not (R18)", async () => {
+    await page.goto("/firearms");
+    await page.getByRole("link", { name: "Interval Rifle One" }).click();
+
+    const panel = page.getByRole("region", { name: "Service rules" });
+    const cleaningRow = panel.getByRole("row").filter({ hasText: "Cleaning" });
+    await expect(cleaningRow.getByText("Due")).toBeVisible();
+    await expect(cleaningRow).toContainText("of 7 days");
+
+    const barrelRow = panel.getByRole("row").filter({ hasText: "Barrel" });
+    await expect(barrelRow.getByText("Due")).toHaveCount(0);
+    await expect(barrelRow).toContainText("of 400 days");
+  });
+
+  await test.step("logging service against Cleaning clears its due state (F2)", async () => {
+    await page.getByRole("button", { name: "Log service — Cleaning" }).click();
+    const form = page.locator("form");
+    await form
+      .getByLabel("Notes")
+      .fill("Wiped down and lubed after the range.");
+    await form.getByRole("button", { name: "Log service" }).click();
+    await expect(page.getByText("Logged service — Cleaning")).toBeVisible();
+
+    const panel = page.getByRole("region", { name: "Service rules" });
+    const cleaningRow = panel.getByRole("row").filter({ hasText: "Cleaning" });
+    await expect(cleaningRow.getByText("Due")).toHaveCount(0);
+
+    const history = page.getByRole("region", { name: "Service history" });
+    await expect(history).toContainText("Cleaning");
+    await expect(history).toContainText(
+      "Wiped down and lubed after the range.",
+    );
+  });
+
+  await test.step("the list row and roll-up both clear once the only due rule is logged", async () => {
+    await page.goto("/firearms");
+    await expect(page.getByText("Service due")).toHaveCount(0);
+
+    await page.goto("/summary");
+    await expect(
+      page.getByText("0 items due for service across 0 rules"),
+    ).toBeVisible();
+  });
+
+  await test.step("overriding Barrel on Interval Rifle Two diverges it from the rifle default (F3)", async () => {
+    await page.goto("/firearms");
+    await page.getByRole("link", { name: "Interval Rifle Two" }).click();
+
+    await page.getByRole("button", { name: "Override Barrel" }).click();
+    const form = page.locator("form");
+    await form.getByLabel("Days").fill("1");
+    await page.getByRole("button", { name: "Save override" }).click();
+    await expect(page.getByText("Barrel updated")).toBeVisible();
+
+    const panel = page.getByRole("region", { name: "Service rules" });
+    const barrelRow = panel.getByRole("row").filter({ hasText: "Barrel" });
+    await expect(barrelRow.getByText("Overridden")).toBeVisible();
+    await expect(barrelRow.getByText("Due")).toBeVisible();
+    await expect(barrelRow).toContainText("of 1 day");
+  });
+
+  await test.step("raising the rifle Barrel default reaches Interval Rifle One but leaves Interval Rifle Two's override standing (F3, AE1)", async () => {
+    await page.goto("/settings/service");
+    const rifleSection = page.getByRole("region", { name: "Rifle" });
+    await rifleSection
+      .getByRole("row")
+      .filter({ hasText: "Barrel" })
+      .getByRole("button", { name: "Edit" })
+      .click();
+    const form = rifleSection.locator("form");
+    await form.getByLabel("Days").fill("1000");
+    await rifleSection.getByRole("button", { name: "Save changes" }).click();
+    await expect(page.getByText("Barrel updated")).toBeVisible();
+
+    await page.goto("/firearms");
+    await page.getByRole("link", { name: "Interval Rifle One" }).click();
+    const oneBarrelRow = page
+      .getByRole("region", { name: "Service rules" })
+      .getByRole("row")
+      .filter({ hasText: "Barrel" });
+    await expect(oneBarrelRow.getByText("Inherited")).toBeVisible();
+    await expect(oneBarrelRow).toContainText("of 1000 days");
+
+    await page.goto("/firearms");
+    await page.getByRole("link", { name: "Interval Rifle Two" }).click();
+    const twoBarrelRow = page
+      .getByRole("region", { name: "Service rules" })
+      .getByRole("row")
+      .filter({ hasText: "Barrel" });
+    await expect(twoBarrelRow.getByText("Overridden")).toBeVisible();
+    await expect(twoBarrelRow).toContainText("of 1 day");
+  });
+
+  await test.step("correcting the Cleaning entry's date and notes, then deleting it (correction path)", async () => {
+    await page.goto("/firearms");
+    await page.getByRole("link", { name: "Interval Rifle One" }).click();
+
+    const history = page.getByRole("region", { name: "Service history" });
+    await history
+      .getByRole("button", { name: /^Edit service — Cleaning/ })
+      .click();
+
+    const editForm = history.locator("form");
+    await editForm.getByLabel("Date serviced").fill(isoDateDaysAgo(1));
+    await editForm
+      .getByLabel("Notes")
+      .fill("Corrected: actually cleaned yesterday.");
+    await editForm.getByRole("button", { name: "Save changes" }).click();
+    await expect(page.getByText("Cleaning entry updated")).toBeVisible();
+    await expect(history).toContainText(
+      "Corrected: actually cleaned yesterday.",
+    );
+
+    await history
+      .getByRole("button", { name: /^Delete service — Cleaning/ })
+      .click();
+    await expect(page.getByText("Cleaning entry deleted")).toBeVisible();
+    await expect(history.getByText("No service logged yet")).toBeVisible();
+
+    // With no service event left for Cleaning, due state falls back to the
+    // firearm's acquired date (30 days ago) — well past the 7-day threshold.
+    const panel = page.getByRole("region", { name: "Service rules" });
+    const cleaningRow = panel.getByRole("row").filter({ hasText: "Cleaning" });
+    await expect(cleaningRow.getByText("Due")).toBeVisible();
+  });
+});
diff --git a/scripts/seed-demo.ts b/scripts/seed-demo.ts
index 8a7ba3ab..1143c675 100644
--- a/scripts/seed-demo.ts
+++ b/scripts/seed-demo.ts
@@ -6,6 +6,7 @@ import {
   firearm,
   magazine,
   magazineLabelPrefix,
+  serviceRuleDefault,
 } from "@/src/db/inventory-schema";
 import {
   bulkMagazines,
@@ -13,11 +14,20 @@ import {
   DEMO_AMMO,
   DEMO_FIREARMS,
   DEMO_MAGAZINES,
+  DEMO_SERVICE_DEFAULTS,
+  DEMO_SERVICE_HISTORY,
+  DEMO_SERVICE_OVERRIDES,
+  isoDateDaysAgo,
 } from "@/src/demo/inventory";
 import { createAccessory } from "@/src/domain/accessories/service";
 import { createAmmo } from "@/src/domain/ammo/service";
 import { createFirearm } from "@/src/domain/firearms/service";
 import { createMagazine } from "@/src/domain/magazines/service";
+import { logServiceEvent } from "@/src/domain/service-intervals/events-service";
+import {
+  createItemRule,
+  createServiceRuleDefault,
+} from "@/src/domain/service-intervals/rules-service";
 
 /**
  * Demo inventory seed for a local/dev database.
@@ -50,7 +60,13 @@ import { createMagazine } from "@/src/domain/magazines/service";
  * All or nothing instead.
  *
  * Child-first ordering: accessories reference firearms, so they go before
- * firearms. `magazine_firearm` rows cascade from either side.
+ * firearms. `magazine_firearm` rows cascade from either side. Deleting a
+ * firearm or accessory row cascades its own `service_rule`/`service_event`
+ * rows natively (U1, KTD2) — nothing to do for those here. `service_rule_default`
+ * is owner-scoped rather than a child of any item (it has no parent to cascade
+ * from), so it needs its own explicit delete or a `--reset` run would leave
+ * the demo's category defaults behind and the next seed's
+ * `createServiceRuleDefault` calls would fail on the duplicate-name guard.
  */
 async function resetInventory(ownerId: string): Promise<void> {
   await db.transaction(async (tx) => {
@@ -61,6 +77,9 @@ async function resetInventory(ownerId: string): Promise<void> {
     await tx
       .delete(magazineLabelPrefix)
       .where(eq(magazineLabelPrefix.ownerId, ownerId));
+    await tx
+      .delete(serviceRuleDefault)
+      .where(eq(serviceRuleDefault.ownerId, ownerId));
   });
 }
 
@@ -102,7 +121,20 @@ async function seed(ownerId: string): Promise<void> {
   // Firearms first — accessories mount to them by name, so we need their ids.
   const firearmIdByName = new Map<string, string>();
   for (const f of DEMO_FIREARMS) {
-    const row = await createFirearm(ownerId, f);
+    const row = await createFirearm(ownerId, {
+      name: f.name,
+      caliber: f.caliber,
+      type: f.type,
+      action: f.action,
+      isNfa: f.isNfa ?? false,
+      // Relative to "now" (service-intervals plan, R22/KTD9) — resolved here,
+      // not stored in the demo data, so the origin date (and everything
+      // measured from it) stays fresh across every future seed run.
+      acquiredDate:
+        f.acquiredDaysAgo !== undefined
+          ? isoDateDaysAgo(f.acquiredDaysAgo)
+          : null,
+    });
     firearmIdByName.set(f.name, row.id);
   }
 
@@ -158,6 +190,49 @@ async function seed(ownerId: string): Promise<void> {
       costCents: s.costCents ?? null,
       isNfa: s.isNfa ?? false,
       firearmId,
+      // Relative to "now" (R22-parity, KTD9) — resolved here, not stored in
+      // the demo data, mirroring the firearm acquiredDate seed above.
+      acquiredDate:
+        s.acquiredDaysAgo !== undefined
+          ? isoDateDaysAgo(s.acquiredDaysAgo)
+          : null,
+    });
+  }
+
+  // Service-interval defaults, overrides, and history (service-intervals
+  // plan, U10) — arms the collection from category defaults exactly as an
+  // owner would from settings, then diverges and services a couple of items
+  // so the demo shows a mix of due and not-due rules rather than a uniform
+  // (and uninformative) all-or-nothing state.
+  for (const d of DEMO_SERVICE_DEFAULTS) {
+    await createServiceRuleDefault(ownerId, d);
+  }
+
+  for (const o of DEMO_SERVICE_OVERRIDES) {
+    const firearmId = firearmIdByName.get(o.firearmName);
+    if (!firearmId) {
+      throw new Error(
+        `Demo service override references unknown firearm "${o.firearmName}".`,
+      );
+    }
+    await createItemRule(ownerId, "firearm", firearmId, {
+      name: o.name,
+      suppressed: o.suppressed ?? false,
+      intervalDays: o.intervalDays ?? null,
+    });
+  }
+
+  for (const h of DEMO_SERVICE_HISTORY) {
+    const firearmId = firearmIdByName.get(h.firearmName);
+    if (!firearmId) {
+      throw new Error(
+        `Demo service history references unknown firearm "${h.firearmName}".`,
+      );
+    }
+    await logServiceEvent(ownerId, "firearm", firearmId, {
+      ruleName: h.ruleName,
+      servicedOn: isoDateDaysAgo(h.daysAgo),
+      notes: h.notes ?? "",
     });
   }
 
@@ -187,10 +262,20 @@ async function main(): Promise<void> {
   const shouldReset =
     process.argv.includes("--reset") || process.env.SEED_RESET === "1";
 
-  if (await hasInventory(owner.id)) {
+  // `hasInventory` alone misses an owner who has `service_rule_default` rows
+  // but no inventory yet — a plain run would then try to recreate the same
+  // defaults and fail on the duplicate-name guard, so the preflight has to
+  // check both.
+  const existingDefaults = await db
+    .select({ id: serviceRuleDefault.id })
+    .from(serviceRuleDefault)
+    .where(eq(serviceRuleDefault.ownerId, owner.id))
+    .limit(1);
+
+  if ((await hasInventory(owner.id)) || existingDefaults.length > 0) {
     if (!shouldReset) {
       console.log(
-        "The target account already has inventory; nothing to do. Re-run with --reset to replace it.",
+        "The target account already has inventory or service defaults; nothing to do. Re-run with --reset to replace it.",
       );
       return;
     }
diff --git a/src/backup/table-order.ts b/src/backup/table-order.ts
index 9c3db63a..2f914580 100644
--- a/src/backup/table-order.ts
+++ b/src/backup/table-order.ts
@@ -13,6 +13,9 @@ import {
   magazineLabelPrefix,
   rangeSession,
   rangeSessionAccessory,
+  serviceEvent,
+  serviceRule,
+  serviceRuleDefault,
 } from "../db/inventory-schema";
 import { operatorAudit } from "../db/operator-audit-schema";
 
@@ -38,6 +41,14 @@ import { operatorAudit } from "../db/operator-audit-schema";
  *   `parent_id` carries no FK — see the schema doc comments) so they can sit
  *   anywhere after `user`; placed last among inventory tables since they
  *   logically depend on the items they reference existing first.
+ * - `service_rule_default` (service-intervals plan, U1) FKs to `user` only,
+ *   so it can sit anywhere after `user`; placed right after `accessory` since
+ *   it is category-keyed configuration, not an item child. `service_rule` and
+ *   `service_event` each FK to both `firearm` and `accessory` (nullable,
+ *   exactly-one CHECK — KTD2), so both must follow `accessory`; `service_rule`
+ *   before `service_event` mirrors no dependency between the two (rows in
+ *   either could theoretically restore in any order), but keeping rules
+ *   before events matches the order they are created in during normal use.
  * - `operator_audit` has no FK to anything and is appended last.
  */
 export const EXPORT_TABLE_ORDER: readonly PgTable[] = [
@@ -48,6 +59,9 @@ export const EXPORT_TABLE_ORDER: readonly PgTable[] = [
   magazine,
   ammo,
   accessory,
+  serviceRuleDefault,
+  serviceRule,
+  serviceEvent,
   magazineLabelPrefix,
   magazineFirearm,
   rangeSession,
diff --git a/src/db/__tests__/migration-0020-service-event-conversion.test.ts b/src/db/__tests__/migration-0020-service-event-conversion.test.ts
new file mode 100644
index 00000000..3281b34f
--- /dev/null
+++ b/src/db/__tests__/migration-0020-service-event-conversion.test.ts
@@ -0,0 +1,632 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { randomUUID } from "node:crypto";
+import {
+  cpSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import {
+  PostgreSqlContainer,
+  type StartedPostgreSqlContainer,
+} from "@testcontainers/postgresql";
+import { drizzle, type NodePgDatabase } from "drizzle-orm/node-postgres";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+import { Pool } from "pg";
+import { expectRejects } from "@/src/test-support/assertions";
+import { POSTGRES_IMAGE } from "@/src/test-support/postgres-image";
+
+/**
+ * Closes the P0 coverage gap on `0020_naive_scarlet_spider.sql` — the
+ * service-intervals plan's own words call this "the one irreversible,
+ * destructive step in the whole plan": it converts every firearm
+ * `cleaned`/`lubed` `inventory_log` row into a `service_event`, deletes the
+ * source rows, and narrows `inventory_log_event_type_valid` so those event
+ * types can never be written again. There is no down-migration.
+ *
+ * `bunfig.toml`'s preload (`src/test-support/preload.ts`) migrates a shared
+ * container ONCE, before any test file loads, against a brand-new empty
+ * database — so in every other test file, 0020 always runs with zero
+ * matching rows, and the reconciliation `RAISE EXCEPTION` branches never
+ * fire. This file stands up its OWN ephemeral Postgres containers (mirroring
+ * `src/backup/__tests__/routes.test.ts` and `migrate-exit-code.test.ts`),
+ * migrates each through 0019 only, seeds pre-migration `cleaned`/`lubed`
+ * rows, and THEN applies 0020 — so the conversion, the count reconciliation,
+ * and (via a deliberately separate, modified copy of the SQL — see the
+ * "aborts" describe block below) the rollback path all run against real
+ * data.
+ */
+
+interface JournalEntry {
+  idx: number;
+  version: string;
+  when: number;
+  tag: string;
+  breakpoints: boolean;
+}
+
+interface Journal {
+  version: string;
+  dialect: string;
+  entries: JournalEntry[];
+}
+
+interface ServiceEventRow {
+  id: string;
+  firearm_id: string | null;
+  accessory_id: string | null;
+  rule_name: string;
+  serviced_on: string;
+  actor_id: string | null;
+  notes: string;
+  created_at: Date;
+}
+
+interface InventoryLogRow {
+  id: string;
+  parent_type: string;
+  parent_id: string;
+  event_type: string;
+}
+
+const REPO_MIGRATIONS_DIR = path.join(process.cwd(), "src/db/migrations");
+const MIGRATION_0020_TAG = "0020_naive_scarlet_spider";
+const MIGRATION_0020_FILE = `${MIGRATION_0020_TAG}.sql`;
+const FORCED_MISMATCH_MARKER =
+  "-- TEST-ONLY forced mismatch (never present in the shipped migration)";
+
+/** Every temp dir created by the helpers below, removed together in the last `afterAll`. */
+const tempDirs: string[] = [];
+
+/** Copies the real migrations folder (SQL + journal + snapshots) into a fresh temp dir. */
+function copyMigrationsFolder(): string {
+  const dir = mkdtempSync(path.join(tmpdir(), "u5-migrations-"));
+  cpSync(REPO_MIGRATIONS_DIR, dir, { recursive: true });
+  tempDirs.push(dir);
+  return dir;
+}
+
+function readJournal(dir: string): Journal {
+  return JSON.parse(
+    readFileSync(path.join(dir, "meta", "_journal.json"), "utf8"),
+  ) as Journal;
+}
+
+function writeJournal(dir: string, journal: Journal): void {
+  writeFileSync(
+    path.join(dir, "meta", "_journal.json"),
+    JSON.stringify(journal, null, 2),
+  );
+}
+
+/**
+ * A migrations folder truncated to 0019 — 0020's SQL file AND EVERY
+ * migration after it (not just 0020 itself) are removed from both the
+ * journal and the directory, so `migrate()` against this folder brings a
+ * fresh database to exactly the pre-0020 schema (firearm `cleaned`/`lubed`
+ * still legal, `service_event` already exists since U1 shipped in 0019).
+ *
+ * Slicing at 0020's INDEX (not filtering just its own tag) matters once any
+ * migration ships after 0020 (e.g. 0021's `accessory.acquired_date` column,
+ * added later in the same plan): drizzle-orm's migrator applies every
+ * journal entry newer than the latest one already recorded for a given
+ * database, tracked by the entry's `when` timestamp — NOT by an independent
+ * per-file hash check. Leaving a later migration's file+entry in this
+ * "through 0019" folder would apply it here (out of order, since it has no
+ * dependency on 0020), and its `when` would then become the newest
+ * timestamp this database has recorded. A subsequent full-folder
+ * `runMigrations(pool, REPO_MIGRATIONS_DIR)` compares each pending entry's
+ * `when` against that recorded high-water mark — and 0020's own `when` is
+ * OLDER than a migration generated after it, so it would read as
+ * already-applied and get silently skipped, never running its
+ * cleaned/lubed conversion or narrowing the CHECK at all. Truncating by
+ * index removes that whole class of migration for good, not just today's.
+ */
+function buildMigrationsFolderThrough0019(): string {
+  const dir = copyMigrationsFolder();
+  const journal = readJournal(dir);
+  const cutoffIndex = journal.entries.findIndex(
+    (e) => e.tag === MIGRATION_0020_TAG,
+  );
+  if (cutoffIndex === -1) {
+    throw new Error(
+      `${MIGRATION_0020_TAG} not found in the journal — has it been renamed?`,
+    );
+  }
+  const [keep, drop] = [
+    journal.entries.slice(0, cutoffIndex),
+    journal.entries.slice(cutoffIndex),
+  ];
+  writeJournal(dir, { ...journal, entries: keep });
+  for (const entry of drop) {
+    rmSync(path.join(dir, `${entry.tag}.sql`));
+  }
+  return dir;
+}
+
+/**
+ * A migrations folder that runs the SAME 0000-0019 set, then a MODIFIED copy
+ * of 0020 that forces the reconciliation mismatch: right before the first
+ * `GET DIAGNOSTICS`, it bumps `read_count` by one, so the real `INSERT ...
+ * SELECT` still inserts the correct rows but the count check now disagrees —
+ * exactly the shape a concurrent writer changing the matching row set
+ * between the `SELECT count(*)` and the `INSERT` would produce. This is a
+ * copy written to a temp file; the shipped
+ * `src/db/migrations/0020_naive_scarlet_spider.sql` is never opened for
+ * writing anywhere in this file.
+ */
+function buildMigrationsFolderWithForcedMismatch(): string {
+  const dir = buildMigrationsFolderThrough0019();
+  const originalSql = readFileSync(
+    path.join(REPO_MIGRATIONS_DIR, MIGRATION_0020_FILE),
+    "utf8",
+  );
+  const anchor = "GET DIAGNOSTICS inserted_count = ROW_COUNT;";
+  const forcedSql = originalSql.replace(
+    anchor,
+    `${FORCED_MISMATCH_MARKER}\n  read_count := read_count + 1;\n\n  ${anchor}`,
+  );
+  if (forcedSql === originalSql) {
+    throw new Error(
+      "buildMigrationsFolderWithForcedMismatch: anchor line not found — " +
+        "0020_naive_scarlet_spider.sql's text has changed, update the anchor.",
+    );
+  }
+  writeFileSync(path.join(dir, MIGRATION_0020_FILE), forcedSql);
+
+  const journal = readJournal(dir);
+  const maxWhen = Math.max(...journal.entries.map((e) => e.when));
+  writeJournal(dir, {
+    ...journal,
+    entries: [
+      ...journal.entries,
+      {
+        idx: journal.entries.length,
+        version: journal.version,
+        when: maxWhen + 1,
+        tag: MIGRATION_0020_TAG,
+        breakpoints: true,
+      },
+    ],
+  });
+  return dir;
+}
+
+async function runMigrations(
+  pool: Pool,
+  migrationsFolder: string,
+): Promise<void> {
+  const db: NodePgDatabase = drizzle(pool);
+  await migrate(db, { migrationsFolder });
+}
+
+async function countRows(
+  pool: Pool,
+  table: "inventory_log" | "service_event",
+): Promise<number> {
+  const { rows } = await pool.query<{ count: string }>(
+    `SELECT count(*)::int AS count FROM ${table}`,
+  );
+  return Number(rows[0]?.count ?? 0);
+}
+
+/**
+ * Formats a Date's LOCAL calendar components as "YYYY-MM-DD" — matching how
+ * node-postgres's own parameter serialization (`dateToString` in
+ * `pg/lib/utils.js`) encodes a JS `Date` for insertion: local getters
+ * (`getFullYear`/`getMonth`/`getDate`/...) plus a UTC-offset suffix that
+ * Postgres silently discards for a "timestamp without time zone" column
+ * (which `inventory_log.occurred_at` is). Using the same local getters here,
+ * rather than `toISOString()` (UTC-based), keeps the expected date
+ * deterministic on any runner timezone — this is exactly the
+ * timestamp-to-date cast the fixture-date rule in
+ * docs/solutions/test-failures/timezone-fragile-date-boundary-tests.md warns
+ * about, and fixtures below are built with `new Date(y, monthIndex, d, h, m)`
+ * for the same reason.
+ */
+function localDateOnly(date: Date): string {
+  const year = String(date.getFullYear()).padStart(4, "0");
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+interface LogRowFixture {
+  parentType: "firearm" | "magazine";
+  parentId: string;
+  eventType: string;
+  actorId: string | null;
+  occurredAt: Date;
+  createdAt: Date;
+  notes: string;
+}
+
+async function insertLogRow(pool: Pool, row: LogRowFixture): Promise<void> {
+  await pool.query(
+    `INSERT INTO inventory_log
+       (parent_type, parent_id, event_type, actor_id, occurred_at, notes, created_at)
+     VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+    [
+      row.parentType,
+      row.parentId,
+      row.eventType,
+      row.actorId,
+      row.occurredAt,
+      row.notes,
+      row.createdAt,
+    ],
+  );
+}
+
+async function startMigratedThrough0019(): Promise<{
+  container: StartedPostgreSqlContainer;
+  pool: Pool;
+}> {
+  const container = await new PostgreSqlContainer(POSTGRES_IMAGE)
+    .withDatabase(`u5_${randomUUID().replaceAll("-", "")}`)
+    .start();
+  const pool = new Pool({ connectionString: container.getConnectionUri() });
+  await runMigrations(pool, buildMigrationsFolderThrough0019());
+  return { container, pool };
+}
+
+describe("migration 0020 — cleaned/lubed to service_event conversion (real data)", () => {
+  let container: StartedPostgreSqlContainer;
+  let pool: Pool;
+  let firearmId: string;
+  let magazineId: string;
+  let userId: string;
+
+  const CLEANED_OCCURRED_AT = new Date(2025, 4, 1, 9, 0); // local: May 1, 2025, 09:00
+  const CLEANED_CREATED_AT = new Date(2025, 4, 1, 9, 5);
+  const LUBED_OCCURRED_AT = new Date(2025, 5, 10, 14, 30); // local: Jun 10, 2025, 14:30
+  const LUBED_CREATED_AT = new Date(2025, 5, 10, 14, 31);
+  const INVENTORIED_OCCURRED_AT = new Date(2025, 6, 1, 8, 0);
+  const INVENTORIED_CREATED_AT = new Date(2025, 6, 1, 8, 1);
+  const NULL_ACTOR_OCCURRED_AT = new Date(2025, 7, 1, 10, 0); // local: Aug 1, 2025, 10:00
+  const NULL_ACTOR_CREATED_AT = new Date(2025, 7, 1, 10, 1);
+  const MAGAZINE_OCCURRED_AT = new Date(2025, 8, 1, 11, 0);
+  const MAGAZINE_CREATED_AT = new Date(2025, 8, 1, 11, 1);
+
+  let preMigrationInventoryLogCount: number;
+  let preMigrationCleanedOrLubedCount: number;
+  let postMigrationServiceEvents: ServiceEventRow[];
+  let postMigrationInventoryLog: InventoryLogRow[];
+
+  beforeAll(async () => {
+    const started = await startMigratedThrough0019();
+    container = started.container;
+    pool = started.pool;
+
+    userId = `test-user-${randomUUID()}`;
+    await pool.query(
+      `INSERT INTO "user" (id, name, email) VALUES ($1, $2, $3)`,
+      [userId, "Migration Test Owner", `${userId}@example.test`],
+    );
+
+    const { rows: firearmRows } = await pool.query<{ id: string }>(
+      `INSERT INTO firearm (owner_id, name, caliber) VALUES ($1, $2, $3) RETURNING id`,
+      [userId, "Test FA", "9mm"],
+    );
+    firearmId = firearmRows[0]?.id ?? "";
+
+    const { rows: magazineRows } = await pool.query<{ id: string }>(
+      `INSERT INTO magazine (owner_id, brand_model, caliber, base_capacity)
+       VALUES ($1, $2, $3, $4) RETURNING id`,
+      [userId, "Test MG", "9mm", 15],
+    );
+    magazineId = magazineRows[0]?.id ?? "";
+
+    // Covers AE6: a firearm with a `cleaned` entry (any date works for the
+    // migration's own logic — the "three-month-old" framing is about the
+    // Last Inventoried derivation elsewhere, not this SQL's date handling).
+    await insertLogRow(pool, {
+      parentType: "firearm",
+      parentId: firearmId,
+      eventType: "cleaned",
+      actorId: userId,
+      occurredAt: CLEANED_OCCURRED_AT,
+      createdAt: CLEANED_CREATED_AT,
+      notes: "cleaned-row-a",
+    });
+    await insertLogRow(pool, {
+      parentType: "firearm",
+      parentId: firearmId,
+      eventType: "lubed",
+      actorId: userId,
+      occurredAt: LUBED_OCCURRED_AT,
+      createdAt: LUBED_CREATED_AT,
+      notes: "lubed-row-b",
+    });
+    // `inventoried` must survive the conversion untouched.
+    await insertLogRow(pool, {
+      parentType: "firearm",
+      parentId: firearmId,
+      eventType: "inventoried",
+      actorId: userId,
+      occurredAt: INVENTORIED_OCCURRED_AT,
+      createdAt: INVENTORIED_CREATED_AT,
+      notes: "inventoried-row-c",
+    });
+    // A `cleaned` row whose actor was since deleted — actor_id is nullable
+    // (ON DELETE SET NULL), so a direct NULL is the faithful fixture for
+    // "the acting user was deleted" (mirrors makeServiceEvent's own doc
+    // comment on the same shape).
+    await insertLogRow(pool, {
+      parentType: "firearm",
+      parentId: firearmId,
+      eventType: "cleaned",
+      actorId: null,
+      occurredAt: NULL_ACTOR_OCCURRED_AT,
+      createdAt: NULL_ACTOR_CREATED_AT,
+      notes: "cleaned-row-d-null-actor",
+    });
+    // A magazine's `inventoried` entry — parent_type='magazine' can never
+    // carry cleaned/lubed (pre-0020 CHECK already forbids it), so this is
+    // untouched by construction; asserted below for the record.
+    await insertLogRow(pool, {
+      parentType: "magazine",
+      parentId: magazineId,
+      eventType: "inventoried",
+      actorId: userId,
+      occurredAt: MAGAZINE_OCCURRED_AT,
+      createdAt: MAGAZINE_CREATED_AT,
+      notes: "inventoried-row-e-magazine",
+    });
+
+    preMigrationInventoryLogCount = await countRows(pool, "inventory_log");
+    const { rows: cleanedOrLubedRows } = await pool.query<{ count: string }>(
+      `SELECT count(*)::int AS count FROM inventory_log
+        WHERE parent_type = 'firearm' AND event_type IN ('cleaned', 'lubed')`,
+    );
+    preMigrationCleanedOrLubedCount = Number(cleanedOrLubedRows[0]?.count ?? 0);
+
+    // Verification: `bun run db:migrate` applies the shipped, UNMODIFIED
+    // migration against a database seeded with pre-migration cleaned/lubed
+    // rows — this is the real repo migrations folder, not a copy.
+    await runMigrations(pool, REPO_MIGRATIONS_DIR);
+
+    const { rows: serviceEventRows } = await pool.query<ServiceEventRow>(
+      `SELECT id, firearm_id, accessory_id, rule_name,
+              serviced_on::text AS serviced_on, actor_id, notes, created_at
+         FROM service_event`,
+    );
+    postMigrationServiceEvents = serviceEventRows;
+
+    const { rows: inventoryLogRows } = await pool.query<InventoryLogRow>(
+      `SELECT id, parent_type, parent_id, event_type FROM inventory_log`,
+    );
+    postMigrationInventoryLog = inventoryLogRows;
+  }, 60_000);
+
+  afterAll(async () => {
+    await pool.end();
+    await container.stop();
+  }, 30_000);
+
+  test("pre-migration fixture: 5 inventory_log rows, 3 of them firearm cleaned/lubed", () => {
+    expect(preMigrationInventoryLogCount).toBe(5);
+    expect(preMigrationCleanedOrLubedCount).toBe(3);
+  });
+
+  test("scenario 1 (AE6): the cleaned entry becomes one Cleaning service_event on its date, and the source row is gone", () => {
+    const converted = postMigrationServiceEvents.find(
+      (e) => e.notes === "cleaned-row-a",
+    );
+    expect(converted).toBeDefined();
+    expect(converted?.rule_name).toBe("Cleaning");
+    expect(converted?.serviced_on).toBe(localDateOnly(CLEANED_OCCURRED_AT));
+    expect(
+      postMigrationInventoryLog.some((r) => r.event_type === "cleaned"),
+    ).toBe(false);
+  });
+
+  test("scenario 2: the lubed entry becomes a Lubrication event, preserving actor and notes", () => {
+    const converted = postMigrationServiceEvents.find(
+      (e) => e.notes === "lubed-row-b",
+    );
+    expect(converted).toBeDefined();
+    expect(converted?.rule_name).toBe("Lubrication");
+    expect(converted?.actor_id).toBe(userId);
+    expect(converted?.notes).toBe("lubed-row-b");
+  });
+
+  test("scenario 3: the inventoried entry is untouched and still available for the Last Inventoried derivation", () => {
+    const untouched = postMigrationInventoryLog.find(
+      (r) => r.event_type === "inventoried" && r.parent_type === "firearm",
+    );
+    expect(untouched).toBeDefined();
+    expect(untouched?.parent_id).toBe(firearmId);
+  });
+
+  test("scenario 4: the converted event count equals the pre-migration cleaned+lubed count", () => {
+    expect(postMigrationServiceEvents.length).toBe(
+      preMigrationCleanedOrLubedCount,
+    );
+    expect(postMigrationServiceEvents.length).toBe(3);
+  });
+
+  test("scenario 5: the magazine's inventoried entry is untouched", () => {
+    const magazineRow = postMigrationInventoryLog.find(
+      (r) => r.parent_type === "magazine",
+    );
+    expect(magazineRow).toBeDefined();
+    expect(magazineRow?.parent_id).toBe(magazineId);
+    expect(magazineRow?.event_type).toBe("inventoried");
+  });
+
+  test("field fidelity: actor_id, notes, created_at carry through verbatim; serviced_on equals occurred_at::date", () => {
+    const cleaned = postMigrationServiceEvents.find(
+      (e) => e.notes === "cleaned-row-a",
+    );
+    expect(cleaned?.firearm_id).toBe(firearmId);
+    expect(cleaned?.actor_id).toBe(userId);
+    expect(cleaned?.notes).toBe("cleaned-row-a");
+    expect(cleaned?.created_at.getTime()).toBe(CLEANED_CREATED_AT.getTime());
+    expect(cleaned?.serviced_on).toBe(localDateOnly(CLEANED_OCCURRED_AT));
+
+    const lubed = postMigrationServiceEvents.find(
+      (e) => e.notes === "lubed-row-b",
+    );
+    expect(lubed?.firearm_id).toBe(firearmId);
+    expect(lubed?.created_at.getTime()).toBe(LUBED_CREATED_AT.getTime());
+    expect(lubed?.serviced_on).toBe(localDateOnly(LUBED_OCCURRED_AT));
+  });
+
+  test("a null actor_id source row (deleted acting user) converts without error", () => {
+    const converted = postMigrationServiceEvents.find(
+      (e) => e.notes === "cleaned-row-d-null-actor",
+    );
+    expect(converted).toBeDefined();
+    expect(converted?.actor_id).toBeNull();
+    expect(converted?.rule_name).toBe("Cleaning");
+    expect(converted?.serviced_on).toBe(localDateOnly(NULL_ACTOR_OCCURRED_AT));
+  });
+});
+
+describe("migration 0020 — empty database (no cleaned/lubed rows anywhere)", () => {
+  let container: StartedPostgreSqlContainer;
+  let pool: Pool;
+
+  beforeAll(async () => {
+    const started = await startMigratedThrough0019();
+    container = started.container;
+    pool = started.pool;
+    // Deliberately no inventory_log rows at all — the empty case.
+    await runMigrations(pool, REPO_MIGRATIONS_DIR);
+  }, 60_000);
+
+  afterAll(async () => {
+    await pool.end();
+    await container.stop();
+  }, 30_000);
+
+  test("migrates cleanly with zero rows in both tables", async () => {
+    expect(await countRows(pool, "inventory_log")).toBe(0);
+    expect(await countRows(pool, "service_event")).toBe(0);
+  });
+
+  test("the narrowed CHECK is live — a fresh firearm cleaned row is rejected", async () => {
+    const userId = `test-user-${randomUUID()}`;
+    await pool.query(
+      `INSERT INTO "user" (id, name, email) VALUES ($1, $2, $3)`,
+      [userId, "Empty DB Owner", `${userId}@example.test`],
+    );
+    const { rows } = await pool.query<{ id: string }>(
+      `INSERT INTO firearm (owner_id, name, caliber) VALUES ($1, $2, $3) RETURNING id`,
+      [userId, "Test FA", "9mm"],
+    );
+    const firearmId = rows[0]?.id ?? "";
+
+    await expectRejects(() =>
+      pool.query(
+        `INSERT INTO inventory_log (parent_type, parent_id, event_type, actor_id)
+         VALUES ('firearm', $1, 'cleaned', $2)`,
+        [firearmId, userId],
+      ),
+    );
+  });
+});
+
+describe("migration 0020 — aborts and rolls back completely on a reconciliation mismatch", () => {
+  let container: StartedPostgreSqlContainer;
+  let pool: Pool;
+  let firearmId: string;
+  let preInventoryLogRows: InventoryLogRow[];
+
+  beforeAll(async () => {
+    const started = await startMigratedThrough0019();
+    container = started.container;
+    pool = started.pool;
+
+    const userId = `test-user-${randomUUID()}`;
+    await pool.query(
+      `INSERT INTO "user" (id, name, email) VALUES ($1, $2, $3)`,
+      [userId, "Abort Path Owner", `${userId}@example.test`],
+    );
+    const { rows } = await pool.query<{ id: string }>(
+      `INSERT INTO firearm (owner_id, name, caliber) VALUES ($1, $2, $3) RETURNING id`,
+      [userId, "Test FA", "9mm"],
+    );
+    firearmId = rows[0]?.id ?? "";
+
+    await insertLogRow(pool, {
+      parentType: "firearm",
+      parentId: firearmId,
+      eventType: "cleaned",
+      actorId: userId,
+      occurredAt: new Date(2025, 4, 1, 9, 0),
+      createdAt: new Date(2025, 4, 1, 9, 5),
+      notes: "cleaned-row-f",
+    });
+    await insertLogRow(pool, {
+      parentType: "firearm",
+      parentId: firearmId,
+      eventType: "lubed",
+      actorId: userId,
+      occurredAt: new Date(2025, 5, 10, 14, 30),
+      createdAt: new Date(2025, 5, 10, 14, 31),
+      notes: "lubed-row-g",
+    });
+
+    const { rows: inventoryLogRows } = await pool.query<InventoryLogRow>(
+      `SELECT id, parent_type, parent_id, event_type FROM inventory_log ORDER BY id`,
+    );
+    preInventoryLogRows = inventoryLogRows;
+
+    // The forced mismatch runs from a temp-file copy of 0020's SQL — never
+    // the shipped file — see buildMigrationsFolderWithForcedMismatch's doc
+    // comment.
+    await expectRejects(() =>
+      runMigrations(pool, buildMigrationsFolderWithForcedMismatch()),
+    );
+  }, 60_000);
+
+  afterAll(async () => {
+    await pool.end();
+    await container.stop();
+  }, 30_000);
+
+  test("nothing was inserted into service_event", async () => {
+    expect(await countRows(pool, "service_event")).toBe(0);
+  });
+
+  test("both source inventory_log rows are still exactly as they were", async () => {
+    const { rows } = await pool.query<InventoryLogRow>(
+      `SELECT id, parent_type, parent_id, event_type FROM inventory_log ORDER BY id`,
+    );
+    expect(rows).toEqual(preInventoryLogRows);
+  });
+
+  test("the CHECK constraint was never narrowed — a fresh firearm cleaned row is still accepted", async () => {
+    const userId = `test-user-${randomUUID()}`;
+    await pool.query(
+      `INSERT INTO "user" (id, name, email) VALUES ($1, $2, $3)`,
+      [userId, "Post-Abort Actor", `${userId}@example.test`],
+    );
+    const { rowCount } = await pool.query(
+      `INSERT INTO inventory_log (parent_type, parent_id, event_type, actor_id)
+       VALUES ('firearm', $1, 'cleaned', $2)`,
+      [firearmId, userId],
+    );
+    expect(rowCount).toBe(1);
+  });
+
+  test("the shipped migration file was never touched by the forced-mismatch copy", () => {
+    const shipped = readFileSync(
+      path.join(REPO_MIGRATIONS_DIR, MIGRATION_0020_FILE),
+      "utf8",
+    );
+    expect(shipped).not.toContain(FORCED_MISMATCH_MARKER);
+    expect(shipped).not.toContain("read_count := read_count + 1;");
+  });
+});
+
+afterAll(() => {
+  for (const dir of tempDirs) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
diff --git a/src/db/__tests__/service-intervals-schema.test.ts b/src/db/__tests__/service-intervals-schema.test.ts
new file mode 100644
index 00000000..dbda4ab5
--- /dev/null
+++ b/src/db/__tests__/service-intervals-schema.test.ts
@@ -0,0 +1,326 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { randomUUID } from "node:crypto";
+import { eq } from "drizzle-orm";
+import { expectRejects } from "@/src/test-support/assertions";
+import {
+  makeAccessory,
+  makeFirearm,
+  makeServiceRule,
+  makeServiceRuleDefault,
+} from "@/src/test-support/factories";
+import { db } from "../client";
+import {
+  accessory,
+  firearm,
+  serviceEvent,
+  serviceRule,
+  serviceRuleDefault,
+  user,
+} from "../schema";
+
+/**
+ * `service_rule_default` / `service_rule` / `service_event` schema (U1) — the
+ * exactly-one-parent CHECKs (KTD2), the threshold CHECKs (R2), the
+ * suppression shape CHECK (KTD6), the uniqueness constraints, and the FK
+ * cascade/set-null behavior. Domain-level behavior (authorization,
+ * inheritance resolution) lives in later units' service-layer tests; this
+ * covers the DB backstops only.
+ */
+describe("service-intervals schema (U1)", () => {
+  const ownerId = `test-user-${randomUUID()}`;
+
+  beforeAll(async () => {
+    await db.insert(user).values({
+      id: ownerId,
+      name: "Service Schema Test",
+      email: `${ownerId}@example.test`,
+    });
+  });
+
+  afterAll(async () => {
+    // Cascade removes this user's firearms/accessories, and in turn their
+    // service_rule/service_event rows.
+    await db.delete(user).where(eq(user.id, ownerId));
+  });
+
+  test("a service_rule row with both firearm_id and accessory_id set is rejected", async () => {
+    const f = await makeFirearm(ownerId);
+    const acc = await makeAccessory(ownerId);
+
+    await expectRejects(() =>
+      db.insert(serviceRule).values({
+        firearmId: f.id,
+        accessoryId: acc.id,
+        name: "Cleaning",
+        intervalRounds: 500,
+      }),
+    );
+  });
+
+  test("a service_rule row with neither parent set is rejected", async () => {
+    await expectRejects(() =>
+      db.insert(serviceRule).values({
+        name: "Cleaning",
+        intervalRounds: 500,
+      }),
+    );
+  });
+
+  test("a service_event row with both parents set is rejected", async () => {
+    const f = await makeFirearm(ownerId);
+    const acc = await makeAccessory(ownerId);
+
+    await expectRejects(() =>
+      db.insert(serviceEvent).values({
+        firearmId: f.id,
+        accessoryId: acc.id,
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+      }),
+    );
+  });
+
+  test("a service_event row with neither parent set is rejected", async () => {
+    await expectRejects(() =>
+      db.insert(serviceEvent).values({
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+      }),
+    );
+  });
+
+  test("a service_rule_default row with all three thresholds null is rejected", async () => {
+    await expectRejects(() =>
+      db.insert(serviceRuleDefault).values({
+        ownerId,
+        scope: "firearm",
+        category: "rifle",
+        name: "No Threshold",
+      }),
+    );
+  });
+
+  test("a service_rule_default row with a zero or negative threshold is rejected", async () => {
+    await expectRejects(() =>
+      db.insert(serviceRuleDefault).values({
+        ownerId,
+        scope: "firearm",
+        category: "rifle",
+        name: "Zero Threshold",
+        intervalRounds: 0,
+      }),
+    );
+
+    await expectRejects(() =>
+      db.insert(serviceRuleDefault).values({
+        ownerId,
+        scope: "firearm",
+        category: "rifle",
+        name: "Negative Threshold",
+        intervalDays: -1,
+      }),
+    );
+  });
+
+  test("a service_rule_default row with an invalid scope is rejected", async () => {
+    await expectRejects(() =>
+      db.insert(serviceRuleDefault).values({
+        ownerId,
+        scope: "magazine",
+        category: "rifle",
+        name: "Bad Scope",
+        intervalRounds: 500,
+      }),
+    );
+  });
+
+  test("a suppressed service_rule row carrying a threshold is rejected", async () => {
+    const f = await makeFirearm(ownerId);
+
+    await expectRejects(() =>
+      db.insert(serviceRule).values({
+        firearmId: f.id,
+        name: "Cleaning",
+        suppressed: true,
+        intervalRounds: 500,
+      }),
+    );
+  });
+
+  test("a suppressed service_rule row with no thresholds is accepted", async () => {
+    const f = await makeFirearm(ownerId);
+
+    // The factory nulls all three thresholds itself when `suppressed` is
+    // true, so this doesn't need to null `intervalRounds` by hand.
+    const row = await makeServiceRule(
+      { firearmId: f.id },
+      { name: "Cleaning", suppressed: true },
+    );
+    expect(row.suppressed).toBe(true);
+    expect(row.intervalRounds).toBeNull();
+  });
+
+  test("an unsuppressed service_rule row with no thresholds is rejected", async () => {
+    const f = await makeFirearm(ownerId);
+
+    await expectRejects(() =>
+      db.insert(serviceRule).values({
+        firearmId: f.id,
+        name: "Cleaning",
+        suppressed: false,
+      }),
+    );
+  });
+
+  test("two service_rule rows with the same name on the same firearm are rejected; the same two names on two different firearms are accepted", async () => {
+    const firearmA = await makeFirearm(ownerId);
+    const firearmB = await makeFirearm(ownerId);
+
+    await makeServiceRule({ firearmId: firearmA.id }, { name: "Barrel" });
+    await expectRejects(() =>
+      db.insert(serviceRule).values({
+        firearmId: firearmA.id,
+        name: "Barrel",
+        intervalRounds: 4000,
+      }),
+    );
+
+    // Same name on a different firearm is fine.
+    const rowB = await makeServiceRule(
+      { firearmId: firearmB.id },
+      { name: "Barrel" },
+    );
+    expect(rowB.firearmId).toBe(firearmB.id);
+  });
+
+  test("two service_rule rows with the same name on two different accessories are accepted (no collision across NULL parents)", async () => {
+    const accessoryA = await makeAccessory(ownerId);
+    const accessoryB = await makeAccessory(ownerId);
+
+    const rowA = await makeServiceRule(
+      { accessoryId: accessoryA.id },
+      { name: "Cleaning" },
+    );
+    const rowB = await makeServiceRule(
+      { accessoryId: accessoryB.id },
+      { name: "Cleaning" },
+    );
+    expect(rowA.accessoryId).toBe(accessoryA.id);
+    expect(rowB.accessoryId).toBe(accessoryB.id);
+  });
+
+  test("deleting a firearm removes its service_rule and service_event rows without a trigger (FK cascade)", async () => {
+    const f = await makeFirearm(ownerId);
+    const rule = await makeServiceRule({ firearmId: f.id });
+    await db.insert(serviceEvent).values({
+      firearmId: f.id,
+      ruleName: rule.name,
+      servicedOn: "2026-01-01",
+    });
+
+    await db.delete(firearm).where(eq(firearm.id, f.id));
+
+    const rules = await db
+      .select()
+      .from(serviceRule)
+      .where(eq(serviceRule.firearmId, f.id));
+    expect(rules).toHaveLength(0);
+
+    const events = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, f.id));
+    expect(events).toHaveLength(0);
+  });
+
+  test("deleting an accessory removes its service_rule and service_event rows without a trigger (FK cascade)", async () => {
+    const acc = await makeAccessory(ownerId);
+    const rule = await makeServiceRule({ accessoryId: acc.id });
+    await db.insert(serviceEvent).values({
+      accessoryId: acc.id,
+      ruleName: rule.name,
+      servicedOn: "2026-01-01",
+    });
+
+    await db.delete(accessory).where(eq(accessory.id, acc.id));
+
+    const rules = await db
+      .select()
+      .from(serviceRule)
+      .where(eq(serviceRule.accessoryId, acc.id));
+    expect(rules).toHaveLength(0);
+
+    const events = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.accessoryId, acc.id));
+    expect(events).toHaveLength(0);
+  });
+
+  test("deleting the acting user leaves a service_event row in place with a null actor_id", async () => {
+    const actorId = `test-actor-${randomUUID()}`;
+    await db.insert(user).values({
+      id: actorId,
+      name: "Actor",
+      email: `${actorId}@example.test`,
+    });
+    const f = await makeFirearm(ownerId);
+    const [event] = await db
+      .insert(serviceEvent)
+      .values({
+        firearmId: f.id,
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+        actorId,
+      })
+      .returning();
+
+    await db.delete(user).where(eq(user.id, actorId));
+
+    const [reloaded] = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.id, event.id));
+    expect(reloaded).toBeDefined();
+    expect(reloaded.actorId).toBeNull();
+  });
+
+  test("a service_rule_default row for one owner is a separate row from an identically-named default for another owner", async () => {
+    const otherOwnerId = `test-other-owner-${randomUUID()}`;
+    await db.insert(user).values({
+      id: otherOwnerId,
+      name: "Other Owner",
+      email: `${otherOwnerId}@example.test`,
+    });
+
+    await makeServiceRuleDefault(ownerId, {
+      category: "rifle",
+      name: "Barrel",
+    });
+    // Same (scope, category, name) for a different owner is fine — the
+    // unique constraint is scoped by owner_id.
+    const other = await makeServiceRuleDefault(otherOwnerId, {
+      category: "rifle",
+      name: "Barrel",
+    });
+    expect(other.ownerId).toBe(otherOwnerId);
+
+    await db.delete(user).where(eq(user.id, otherOwnerId));
+  });
+
+  test("two service_rule_default rows with the same (owner, scope, category, name) are rejected", async () => {
+    await makeServiceRuleDefault(ownerId, {
+      category: "pistol",
+      name: "Cleaning",
+    });
+    await expectRejects(() =>
+      db.insert(serviceRuleDefault).values({
+        ownerId,
+        scope: "firearm",
+        category: "pistol",
+        name: "Cleaning",
+        intervalDays: 30,
+      }),
+    );
+  });
+});
diff --git a/src/db/inventory-schema.ts b/src/db/inventory-schema.ts
index 72e40f78..5b636eb9 100644
--- a/src/db/inventory-schema.ts
+++ b/src/db/inventory-schema.ts
@@ -43,7 +43,7 @@ function inList(values: readonly string[]): string {
  *   Better Auth user ids are text) with an index for visibility lookups (R72).
  *   Parents use uuid PKs (R8, R64).
  * - Optional TEXT fields are NOT NULL DEFAULT '' (the empty-not-null rule, R18).
- *   Optional date/numeric fields that can be "unset" use NULL (KTD-7).
+ *   Optional date/numeric fields that can be "unset" use NULL, not zero.
  * - `magazine_firearm` carries the compatibility ordinal (KTD-8) with both FKs
  *   ON DELETE CASCADE (R35) and a composite PK preventing duplicate pairs (R34).
  * - A single polymorphic `grant` table attaches to a parent by type+id and
@@ -86,6 +86,12 @@ export const firearm = pgTable(
     // NFA-regulated item flag (#8). Backfills existing rows to
     // false on ADD COLUMN (R12-style).
     isNfa: boolean("is_nfa").notNull().default(false),
+    // NULL = unset, not zero; calendar date, no time component. Mirrors
+    // `magazine.acquiredDate` / `ammo.acquiredDate` (service-intervals plan
+    // R22) — it is also the origin date the service-interval day axis
+    // measures from when set (KTD9 in that plan), falling back to
+    // `createdAt` when null.
+    acquiredDate: date("acquired_date"),
     createdAt: timestamp("created_at").defaultNow().notNull(),
     updatedAt: timestamp("updated_at").defaultNow().notNull(),
   },
@@ -116,7 +122,7 @@ export const magazine = pgTable(
     baseCapacity: integer("base_capacity").notNull(),
     extensionRounds: integer("extension_rounds").notNull().default(0),
     label: text("label").notNull().default(""),
-    // NULL = unset (KTD-7); calendar date, no time component.
+    // NULL = unset (not zero); calendar date, no time component.
     acquiredDate: date("acquired_date"),
     notes: text("notes").notNull().default(""),
     createdAt: timestamp("created_at").defaultNow().notNull(),
@@ -155,7 +161,7 @@ export const ammo = pgTable(
     grain: integer("grain").notNull().default(0),
     quantityRounds: integer("quantity_rounds").notNull().default(0),
     lowStockThreshold: integer("low_stock_threshold").notNull().default(0),
-    // NULL = unset (KTD-7); calendar date, no time component.
+    // NULL = unset (not zero); calendar date, no time component.
     acquiredDate: date("acquired_date"),
     notes: text("notes").notNull().default(""),
     createdAt: timestamp("created_at").defaultNow().notNull(),
@@ -178,8 +184,8 @@ export const ammo = pgTable(
  * `onDelete: "set null"` — deleting a firearm unmounts its accessories rather
  * than deleting them (they remain owner inventory). `category` is the only
  * required text field (mirrors ammo's `caliber`); the rest are empty-not-null
- * (R18). `cost_cents` is nullable (KTD-7-style: unset cost is unknown, not
- * zero) with a non-negative CHECK that only bounds non-null values. `is_nfa`
+ * (R18). `cost_cents` is nullable (unset cost is unknown, not zero) with a
+ * non-negative CHECK that only bounds non-null values. `is_nfa`
  * flags NFA-regulated accessories (suppressors, SBR stocks, etc.), mirroring
  * the new `firearm.is_nfa` column.
  */
@@ -197,8 +203,18 @@ export const accessory = pgTable(
     brand: text("brand").notNull().default(""),
     model: text("model").notNull().default(""),
     serialNumber: text("serial_number").notNull().default(""),
-    // NULL = unset (KTD-7); calendar date, no time component.
+    // NULL = unset (not zero); calendar date, no time component.
     installedDate: date("installed_date"),
+    // NULL = unset, not zero; calendar date, no time component. Mirrors
+    // `firearm.acquiredDate` (service-intervals plan R22) — added during
+    // implementation (see the plan's "Scope added during implementation"
+    // note) because leaving it out reproduced R22's cold-start problem on
+    // accessories: one entered today with no acquired date reads as not-due
+    // on day one even when it's actually been owned for years. It is also
+    // the origin date the service-interval day axis measures from when set
+    // (KTD9), falling back to `createdAt` when null — `installedDate` can
+    // never serve that role since it is force-nulled on unmount.
+    acquiredDate: date("acquired_date"),
     costCents: integer("cost_cents"),
     notes: text("notes").notNull().default(""),
     isNfa: boolean("is_nfa").notNull().default(false),
@@ -450,6 +466,185 @@ export const firearmDocument = pgTable(
   ],
 );
 
+/**
+ * Service rule default (service-intervals plan, U1) — an owner-scoped default
+ * rule set keyed by category: `scope` is `'firearm'` (category = firearm
+ * `type`) or `'accessory'` (category = accessory `category` as typed, KD10).
+ * `unique(owner_id, scope, category, name)` prevents two default rules
+ * sharing a name within one owner's category (R2). At least one of the three
+ * thresholds must be non-null (R2) and every non-null threshold must be >= 1
+ * (R26-style backstop) — enforced by the two CHECKs below rather than one
+ * combined expression, so a failure names which invariant broke. No FK to
+ * `firearm`/`accessory`: a default's category is a value, not a reference
+ * (KTD8 — the accessory-category list itself is derived on read, never
+ * stored here).
+ */
+export const serviceRuleDefault = pgTable(
+  "service_rule_default",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    ownerId: text("owner_id")
+      .notNull()
+      .references(() => user.id, { onDelete: "cascade" }),
+    scope: text("scope").notNull(),
+    category: text("category").notNull(),
+    name: text("name").notNull(),
+    // Nullable thresholds (unset means "not tracked on this axis", not
+    // zero). At least one must be set — see the CHECK below.
+    intervalDays: integer("interval_days"),
+    intervalSessions: integer("interval_sessions"),
+    intervalRounds: integer("interval_rounds"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+  },
+  (t) => [
+    index("service_rule_default_owner_id_idx").on(t.ownerId),
+    unique("service_rule_default_owner_scope_category_name_unique").on(
+      t.ownerId,
+      t.scope,
+      t.category,
+      t.name,
+    ),
+    check(
+      "service_rule_default_scope_valid",
+      sql`${t.scope} in ('firearm', 'accessory')`,
+    ),
+    check(
+      "service_rule_default_has_threshold",
+      sql`num_nonnulls(${t.intervalDays}, ${t.intervalSessions}, ${t.intervalRounds}) >= 1`,
+    ),
+    check(
+      "service_rule_default_thresholds_min",
+      sql`(${t.intervalDays} IS NULL OR ${t.intervalDays} >= 1) AND (${t.intervalSessions} IS NULL OR ${t.intervalSessions} >= 1) AND (${t.intervalRounds} IS NULL OR ${t.intervalRounds} >= 1)`,
+    ),
+  ],
+);
+
+/**
+ * Service rule (service-intervals plan, U1) — a per-item rule row attached to
+ * a firearm or an accessory through two nullable FKs with an exactly-one
+ * CHECK (KTD2), rather than the `parent_type`/`parent_id` shape `grant` and
+ * `inventory_log` use. Real FKs give native `ON DELETE CASCADE`, so no
+ * hand-written cleanup trigger (of the kind `0002_grant_cleanup_triggers.sql`
+ * / `0008_brown_bulldozer.sql` carry) is needed here. A row is one of three
+ * things (KTD6): an override (thresholds set, not suppressed), a suppression
+ * (`suppressed = true`, no thresholds — suppressing and restoring is
+ * inserting/deleting this row, not toggling a separate flag), or an
+ * item-only rule with no matching default (also thresholds set, not
+ * suppressed — indistinguishable at the row level from an override; that
+ * distinction is resolved against the defaults set in the domain layer, not
+ * stored). `unique(firearm_id, name)` / `unique(accessory_id, name)` rely on
+ * Postgres treating NULLs as distinct, so a firearm rule and an accessory
+ * rule never collide with each other even when they share a name. Exactly
+ * one parent, never zero or both: a row with neither FK set would be a
+ * meaningless orphan, and one with both would mean a single rule belongs to
+ * two items at once — incoherent alongside those same per-parent unique
+ * constraints, which only make sense scoped to one item apiece.
+ */
+export const serviceRule = pgTable(
+  "service_rule",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    firearmId: uuid("firearm_id").references(() => firearm.id, {
+      onDelete: "cascade",
+    }),
+    accessoryId: uuid("accessory_id").references(() => accessory.id, {
+      onDelete: "cascade",
+    }),
+    name: text("name").notNull(),
+    suppressed: boolean("suppressed").notNull().default(false),
+    intervalDays: integer("interval_days"),
+    intervalSessions: integer("interval_sessions"),
+    intervalRounds: integer("interval_rounds"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+  },
+  (t) => [
+    index("service_rule_firearm_id_idx").on(t.firearmId),
+    index("service_rule_accessory_id_idx").on(t.accessoryId),
+    unique("service_rule_firearm_name_unique").on(t.firearmId, t.name),
+    unique("service_rule_accessory_name_unique").on(t.accessoryId, t.name),
+    check(
+      "service_rule_exactly_one_parent",
+      sql`num_nonnulls(${t.firearmId}, ${t.accessoryId}) = 1`,
+    ),
+    check(
+      "service_rule_thresholds_min",
+      sql`(${t.intervalDays} IS NULL OR ${t.intervalDays} >= 1) AND (${t.intervalSessions} IS NULL OR ${t.intervalSessions} >= 1) AND (${t.intervalRounds} IS NULL OR ${t.intervalRounds} >= 1)`,
+    ),
+    // Suppressed rows carry no thresholds; unsuppressed rows carry at least
+    // one (approach step 2) — the same shape rule the defaults table
+    // enforces, plus the suppression/threshold exclusivity.
+    check(
+      "service_rule_suppressed_thresholds_consistent",
+      sql`(${t.suppressed} AND num_nonnulls(${t.intervalDays}, ${t.intervalSessions}, ${t.intervalRounds}) = 0) OR (NOT ${t.suppressed} AND num_nonnulls(${t.intervalDays}, ${t.intervalSessions}, ${t.intervalRounds}) >= 1)`,
+    ),
+  ],
+);
+
+/**
+ * Service event (service-intervals plan, U1) — one logged act of service
+ * against a named rule on a firearm or an accessory, same exactly-one-parent
+ * shape as `service_rule` (KTD2) and the same reason for it: a row belongs to
+ * one item's history, never zero (an orphan event nothing can display) and
+ * never two (an event can't have happened to two separate items).
+ * `rule_name` is a plain text column, not an
+ * FK to `service_rule` (KTD1): a rule's identity is its name, and an event
+ * must be able to exist (via the U5 `cleaned`/`lubed` conversion) without a
+ * corresponding rule row ever having been created, so renaming an item rule
+ * re-points its events' `rule_name` in the same transaction rather than
+ * following a reference. `serviced_on` is a calendar `date` (KTD5 — compared
+ * as a calendar day, never an instant); `created_at` is a separate
+ * not-null-defaulted timestamp so several rules serviced on the same
+ * calendar day still sort in a stable insertion order, and so the R15
+ * conversion has somewhere to carry the source `inventory_log` row's
+ * insertion time. `actor_id` FKs to `user` with `ON DELETE SET NULL` —
+ * mirroring `inventory_log.actorId`'s reasoning: the event is a child of its
+ * parent item (already cleaned up by the FK cascade above), not of the
+ * actor, so deleting a user account must never be blocked by service events
+ * that user logged against someone else's shared item.
+ */
+export const serviceEvent = pgTable(
+  "service_event",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    firearmId: uuid("firearm_id").references(() => firearm.id, {
+      onDelete: "cascade",
+    }),
+    accessoryId: uuid("accessory_id").references(() => accessory.id, {
+      onDelete: "cascade",
+    }),
+    ruleName: text("rule_name").notNull(),
+    servicedOn: date("serviced_on").notNull(),
+    actorId: text("actor_id").references(() => user.id, {
+      onDelete: "set null",
+    }),
+    // Empty-not-null (R18-style).
+    notes: text("notes").notNull().default(""),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+  },
+  (t) => [
+    index("service_event_firearm_id_idx").on(t.firearmId),
+    index("service_event_accessory_id_idx").on(t.accessoryId),
+    // Latest-service-point lookup per item and rule name (grouped `max`,
+    // mirroring `loadLastInventoriedBatch`'s query shape).
+    index("service_event_firearm_rule_serviced_idx").on(
+      t.firearmId,
+      t.ruleName,
+      t.servicedOn,
+    ),
+    index("service_event_accessory_rule_serviced_idx").on(
+      t.accessoryId,
+      t.ruleName,
+      t.servicedOn,
+    ),
+    check(
+      "service_event_exactly_one_parent",
+      sql`num_nonnulls(${t.firearmId}, ${t.accessoryId}) = 1`,
+    ),
+  ],
+);
+
 export const grant = pgTable(
   "grant",
   {
@@ -487,7 +682,9 @@ export const grant = pgTable(
 
 /**
  * Inventory event log (U2/U3) — an append-only audit trail of actions taken
- * against a firearm or magazine (inventoried, cleaned, lubed). Polymorphic
+ * against a firearm or magazine (`inventoried`, the only event type either
+ * parent family carries — `cleaned` and `lubed` were retired and converted to
+ * `service_event` rows by the service-intervals plan's U5). Polymorphic
  * `parent_type`/`parent_id` mirrors `grant`: no FK on `parent_id` (it spans
  * two parent tables), with a `parent_type` CHECK plus a parent-gated
  * `event_type` CHECK sourced from `domain/inventory-log/constants.ts` (R3
diff --git a/src/db/migrations/0019_perfect_nebula.sql b/src/db/migrations/0019_perfect_nebula.sql
new file mode 100644
index 00000000..d71caa7f
--- /dev/null
+++ b/src/db/migrations/0019_perfect_nebula.sql
@@ -0,0 +1,61 @@
+CREATE TABLE "service_event" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"firearm_id" uuid,
+	"accessory_id" uuid,
+	"rule_name" text NOT NULL,
+	"serviced_on" date NOT NULL,
+	"actor_id" text,
+	"notes" text DEFAULT '' NOT NULL,
+	"created_at" timestamp DEFAULT now() NOT NULL,
+	CONSTRAINT "service_event_exactly_one_parent" CHECK (num_nonnulls("service_event"."firearm_id", "service_event"."accessory_id") = 1)
+);
+--> statement-breakpoint
+CREATE TABLE "service_rule" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"firearm_id" uuid,
+	"accessory_id" uuid,
+	"name" text NOT NULL,
+	"suppressed" boolean DEFAULT false NOT NULL,
+	"interval_days" integer,
+	"interval_sessions" integer,
+	"interval_rounds" integer,
+	"created_at" timestamp DEFAULT now() NOT NULL,
+	"updated_at" timestamp DEFAULT now() NOT NULL,
+	CONSTRAINT "service_rule_firearm_name_unique" UNIQUE("firearm_id","name"),
+	CONSTRAINT "service_rule_accessory_name_unique" UNIQUE("accessory_id","name"),
+	CONSTRAINT "service_rule_exactly_one_parent" CHECK (num_nonnulls("service_rule"."firearm_id", "service_rule"."accessory_id") = 1),
+	CONSTRAINT "service_rule_thresholds_min" CHECK (("service_rule"."interval_days" IS NULL OR "service_rule"."interval_days" >= 1) AND ("service_rule"."interval_sessions" IS NULL OR "service_rule"."interval_sessions" >= 1) AND ("service_rule"."interval_rounds" IS NULL OR "service_rule"."interval_rounds" >= 1)),
+	CONSTRAINT "service_rule_suppressed_thresholds_consistent" CHECK (("service_rule"."suppressed" AND num_nonnulls("service_rule"."interval_days", "service_rule"."interval_sessions", "service_rule"."interval_rounds") = 0) OR (NOT "service_rule"."suppressed" AND num_nonnulls("service_rule"."interval_days", "service_rule"."interval_sessions", "service_rule"."interval_rounds") >= 1))
+);
+--> statement-breakpoint
+CREATE TABLE "service_rule_default" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"owner_id" text NOT NULL,
+	"scope" text NOT NULL,
+	"category" text NOT NULL,
+	"name" text NOT NULL,
+	"interval_days" integer,
+	"interval_sessions" integer,
+	"interval_rounds" integer,
+	"created_at" timestamp DEFAULT now() NOT NULL,
+	"updated_at" timestamp DEFAULT now() NOT NULL,
+	CONSTRAINT "service_rule_default_owner_scope_category_name_unique" UNIQUE("owner_id","scope","category","name"),
+	CONSTRAINT "service_rule_default_scope_valid" CHECK ("service_rule_default"."scope" in ('firearm', 'accessory')),
+	CONSTRAINT "service_rule_default_has_threshold" CHECK (num_nonnulls("service_rule_default"."interval_days", "service_rule_default"."interval_sessions", "service_rule_default"."interval_rounds") >= 1),
+	CONSTRAINT "service_rule_default_thresholds_min" CHECK (("service_rule_default"."interval_days" IS NULL OR "service_rule_default"."interval_days" >= 1) AND ("service_rule_default"."interval_sessions" IS NULL OR "service_rule_default"."interval_sessions" >= 1) AND ("service_rule_default"."interval_rounds" IS NULL OR "service_rule_default"."interval_rounds" >= 1))
+);
+--> statement-breakpoint
+ALTER TABLE "firearm" ADD COLUMN "acquired_date" date;--> statement-breakpoint
+ALTER TABLE "service_event" ADD CONSTRAINT "service_event_firearm_id_firearm_id_fk" FOREIGN KEY ("firearm_id") REFERENCES "public"."firearm"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "service_event" ADD CONSTRAINT "service_event_accessory_id_accessory_id_fk" FOREIGN KEY ("accessory_id") REFERENCES "public"."accessory"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "service_event" ADD CONSTRAINT "service_event_actor_id_user_id_fk" FOREIGN KEY ("actor_id") REFERENCES "public"."user"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "service_rule" ADD CONSTRAINT "service_rule_firearm_id_firearm_id_fk" FOREIGN KEY ("firearm_id") REFERENCES "public"."firearm"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "service_rule" ADD CONSTRAINT "service_rule_accessory_id_accessory_id_fk" FOREIGN KEY ("accessory_id") REFERENCES "public"."accessory"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "service_rule_default" ADD CONSTRAINT "service_rule_default_owner_id_user_id_fk" FOREIGN KEY ("owner_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "service_event_firearm_id_idx" ON "service_event" USING btree ("firearm_id");--> statement-breakpoint
+CREATE INDEX "service_event_accessory_id_idx" ON "service_event" USING btree ("accessory_id");--> statement-breakpoint
+CREATE INDEX "service_event_firearm_rule_serviced_idx" ON "service_event" USING btree ("firearm_id","rule_name","serviced_on");--> statement-breakpoint
+CREATE INDEX "service_event_accessory_rule_serviced_idx" ON "service_event" USING btree ("accessory_id","rule_name","serviced_on");--> statement-breakpoint
+CREATE INDEX "service_rule_firearm_id_idx" ON "service_rule" USING btree ("firearm_id");--> statement-breakpoint
+CREATE INDEX "service_rule_accessory_id_idx" ON "service_rule" USING btree ("accessory_id");--> statement-breakpoint
+CREATE INDEX "service_rule_default_owner_id_idx" ON "service_rule_default" USING btree ("owner_id");
diff --git a/src/db/migrations/0020_naive_scarlet_spider.sql b/src/db/migrations/0020_naive_scarlet_spider.sql
new file mode 100644
index 00000000..d423c2e3
--- /dev/null
+++ b/src/db/migrations/0020_naive_scarlet_spider.sql
@@ -0,0 +1,74 @@
+-- U5 (service-intervals plan): retiring `cleaned`/`lubed` as firearm
+-- inventory-log event types (R13) and converting every existing entry into a
+-- `service_event` on a seeded Cleaning/Lubrication rule (R15; KTD1, KTD7 — no
+-- `service_rule` row is seeded, only events). This is the one irreversible,
+-- destructive step in the whole plan (see the plan's Risks section): rows
+-- are deleted after conversion and there is no down-migration.
+--
+-- Row-count reconciliation runs inside this DO block: the count of firearm
+-- `cleaned`/`lubed` rows read must equal the count of `service_event` rows
+-- inserted, and must equal the count of `inventory_log` rows deleted. Any
+-- mismatch raises via RAISE EXCEPTION, which aborts and rolls back the whole
+-- migration transaction (drizzle-orm runs all pending migrations in one
+-- `session.transaction`) rather than silently losing or duplicating history.
+--
+-- Ordering matters and must not be reordered: (1) insert the converted
+-- service events, (2) delete the converted inventory_log rows, (3) replace
+-- `inventory_log_event_type_valid` with the narrowed firearm list. Replacing
+-- the CHECK before the delete would reject the table's own historical
+-- `cleaned`/`lubed` rows and fail the migration before conversion ever runs.
+--
+-- Operational assumption: this reconciliation only holds if no other writer
+-- inserts firearm `cleaned`/`lubed` inventory_log rows during the migration
+-- window. drizzle-orm wraps every pending migration in one transaction, so a
+-- mismatch here aborts the whole batch, not just this file.
+DO $$
+DECLARE
+  read_count integer;
+  inserted_count integer;
+  deleted_count integer;
+BEGIN
+  SELECT count(*) INTO read_count
+    FROM "inventory_log"
+   WHERE "parent_type" = 'firearm'
+     AND "event_type" IN ('cleaned', 'lubed');
+
+  INSERT INTO "service_event"
+    ("firearm_id", "rule_name", "serviced_on", "actor_id", "notes", "created_at")
+  SELECT
+    "parent_id",
+    CASE "event_type"
+      WHEN 'cleaned' THEN 'Cleaning'
+      WHEN 'lubed' THEN 'Lubrication'
+    END,
+    "occurred_at"::date,
+    "actor_id",
+    "notes",
+    "created_at"
+  FROM "inventory_log"
+  WHERE "parent_type" = 'firearm'
+    AND "event_type" IN ('cleaned', 'lubed');
+
+  GET DIAGNOSTICS inserted_count = ROW_COUNT;
+
+  IF inserted_count <> read_count THEN
+    RAISE EXCEPTION
+      'U5 service-event conversion mismatch: read % firearm cleaned/lubed inventory_log rows but inserted % service_event rows',
+      read_count, inserted_count;
+  END IF;
+
+  DELETE FROM "inventory_log"
+   WHERE "parent_type" = 'firearm'
+     AND "event_type" IN ('cleaned', 'lubed');
+
+  GET DIAGNOSTICS deleted_count = ROW_COUNT;
+
+  IF deleted_count <> read_count THEN
+    RAISE EXCEPTION
+      'U5 service-event conversion mismatch: read % firearm cleaned/lubed inventory_log rows but deleted % rows',
+      read_count, deleted_count;
+  END IF;
+END $$;
+--> statement-breakpoint
+ALTER TABLE "inventory_log" DROP CONSTRAINT "inventory_log_event_type_valid";--> statement-breakpoint
+ALTER TABLE "inventory_log" ADD CONSTRAINT "inventory_log_event_type_valid" CHECK (("inventory_log"."parent_type" = 'firearm' AND "inventory_log"."event_type" in ('inventoried')) OR ("inventory_log"."parent_type" = 'magazine' AND "inventory_log"."event_type" in ('inventoried')));
diff --git a/src/db/migrations/0021_shocking_shooting_star.sql b/src/db/migrations/0021_shocking_shooting_star.sql
new file mode 100644
index 00000000..0c32f942
--- /dev/null
+++ b/src/db/migrations/0021_shocking_shooting_star.sql
@@ -0,0 +1 @@
+ALTER TABLE "accessory" ADD COLUMN "acquired_date" date;
diff --git a/src/db/migrations/meta/0019_snapshot.json b/src/db/migrations/meta/0019_snapshot.json
new file mode 100644
index 00000000..51d74551
--- /dev/null
+++ b/src/db/migrations/meta/0019_snapshot.json
@@ -0,0 +1,2388 @@
+{
+  "id": "4d0317eb-cca4-4124-84d7-c5091af0a3cf",
+  "prevId": "2193bdc4-6bb6-4152-88b8-279f14d7875b",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.account": {
+      "name": "account",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "id_token": {
+          "name": "id_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_token_expires_at": {
+          "name": "access_token_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token_expires_at": {
+          "name": "refresh_token_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "account_userId_idx": {
+          "name": "account_userId_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "account_user_id_user_id_fk": {
+          "name": "account_user_id_user_id_fk",
+          "tableFrom": "account",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.rate_limit": {
+      "name": "rate_limit",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "count": {
+          "name": "count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_request": {
+          "name": "last_request",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "rate_limit_key_unique": {
+          "name": "rate_limit_key_unique",
+          "nullsNotDistinct": false,
+          "columns": ["key"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.session": {
+      "name": "session",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token": {
+          "name": "token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "impersonated_by": {
+          "name": "impersonated_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "session_userId_idx": {
+          "name": "session_userId_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "session_user_id_user_id_fk": {
+          "name": "session_user_id_user_id_fk",
+          "tableFrom": "session",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "session_token_unique": {
+          "name": "session_token_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user": {
+      "name": "user",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email_verified": {
+          "name": "email_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "image": {
+          "name": "image",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "banned": {
+          "name": "banned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "ban_reason": {
+          "name": "ban_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ban_expires": {
+          "name": "ban_expires",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "magpul_mode": {
+          "name": "magpul_mode",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "user_email_unique": {
+          "name": "user_email_unique",
+          "nullsNotDistinct": false,
+          "columns": ["email"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.verification": {
+      "name": "verification",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "identifier": {
+          "name": "identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "verification_identifier_idx": {
+          "name": "verification_identifier_idx",
+          "columns": [
+            {
+              "expression": "identifier",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.accessory": {
+      "name": "accessory",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "current_firearm_id": {
+          "name": "current_firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "brand": {
+          "name": "brand",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "serial_number": {
+          "name": "serial_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "installed_date": {
+          "name": "installed_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cost_cents": {
+          "name": "cost_cents",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "is_nfa": {
+          "name": "is_nfa",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "accessory_owner_id_idx": {
+          "name": "accessory_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "accessory_current_firearm_id_idx": {
+          "name": "accessory_current_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "current_firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "accessory_owner_id_user_id_fk": {
+          "name": "accessory_owner_id_user_id_fk",
+          "tableFrom": "accessory",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "accessory_current_firearm_id_firearm_id_fk": {
+          "name": "accessory_current_firearm_id_firearm_id_fk",
+          "tableFrom": "accessory",
+          "tableTo": "firearm",
+          "columnsFrom": ["current_firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "accessory_cost_cents_min": {
+          "name": "accessory_cost_cents_min",
+          "value": "\"accessory\".\"cost_cents\" >= 0"
+        },
+        "accessory_installed_date_requires_mount": {
+          "name": "accessory_installed_date_requires_mount",
+          "value": "\"accessory\".\"installed_date\" IS NULL OR \"accessory\".\"current_firearm_id\" IS NOT NULL"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.ammo": {
+      "name": "ammo",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "brand": {
+          "name": "brand",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "caliber": {
+          "name": "caliber",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "grain": {
+          "name": "grain",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "quantity_rounds": {
+          "name": "quantity_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "low_stock_threshold": {
+          "name": "low_stock_threshold",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "acquired_date": {
+          "name": "acquired_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "ammo_owner_id_idx": {
+          "name": "ammo_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "ammo_owner_id_user_id_fk": {
+          "name": "ammo_owner_id_user_id_fk",
+          "tableFrom": "ammo",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "ammo_grain_min": {
+          "name": "ammo_grain_min",
+          "value": "\"ammo\".\"grain\" >= 0"
+        },
+        "ammo_quantity_min": {
+          "name": "ammo_quantity_min",
+          "value": "\"ammo\".\"quantity_rounds\" >= 0"
+        },
+        "ammo_threshold_min": {
+          "name": "ammo_threshold_min",
+          "value": "\"ammo\".\"low_stock_threshold\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.firearm": {
+      "name": "firearm",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "nickname": {
+          "name": "nickname",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "manufacturer": {
+          "name": "manufacturer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "caliber": {
+          "name": "caliber",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'unspecified'"
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'unspecified'"
+        },
+        "subtype": {
+          "name": "subtype",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "serial_number": {
+          "name": "serial_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "is_nfa": {
+          "name": "is_nfa",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "acquired_date": {
+          "name": "acquired_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "firearm_owner_id_idx": {
+          "name": "firearm_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "firearm_owner_id_user_id_fk": {
+          "name": "firearm_owner_id_user_id_fk",
+          "tableFrom": "firearm",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "firearm_type_valid": {
+          "name": "firearm_type_valid",
+          "value": "\"firearm\".\"type\" in ('pistol', 'revolver', 'rifle', 'shotgun', 'pcc', 'other', 'unspecified')"
+        },
+        "firearm_action_valid": {
+          "name": "firearm_action_valid",
+          "value": "\"firearm\".\"action\" in ('semi-auto', 'bolt', 'lever', 'pump', 'break', 'single-shot', 'unspecified')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.firearm_document": {
+      "name": "firearm_document",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "storage_key": {
+          "name": "storage_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "filename": {
+          "name": "filename",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size_bytes": {
+          "name": "size_bytes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "doc_type": {
+          "name": "doc_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'other'"
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "uploaded_at": {
+          "name": "uploaded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "firearm_document_firearm_id_idx": {
+          "name": "firearm_document_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "firearm_document_firearm_id_firearm_id_fk": {
+          "name": "firearm_document_firearm_id_firearm_id_fk",
+          "tableFrom": "firearm_document",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "firearm_document_mime_type_valid": {
+          "name": "firearm_document_mime_type_valid",
+          "value": "\"firearm_document\".\"mime_type\" in ('application/pdf', 'image/jpeg', 'image/png', 'image/webp', 'image/avif')"
+        },
+        "firearm_document_doc_type_valid": {
+          "name": "firearm_document_doc_type_valid",
+          "value": "\"firearm_document\".\"doc_type\" in ('receipt', 'warranty', 'atf-form-1', 'atf-form-4', 'manual', 'insurance', 'other')"
+        },
+        "firearm_document_size_bytes_min": {
+          "name": "firearm_document_size_bytes_min",
+          "value": "\"firearm_document\".\"size_bytes\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.firearm_photo": {
+      "name": "firearm_photo",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "storage_key": {
+          "name": "storage_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size_bytes": {
+          "name": "size_bytes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "width": {
+          "name": "width",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "height": {
+          "name": "height",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "caption": {
+          "name": "caption",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_primary": {
+          "name": "is_primary",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "uploaded_at": {
+          "name": "uploaded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "firearm_photo_firearm_id_idx": {
+          "name": "firearm_photo_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "firearm_photo_one_primary_per_firearm": {
+          "name": "firearm_photo_one_primary_per_firearm",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"firearm_photo\".\"is_primary\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "firearm_photo_firearm_id_firearm_id_fk": {
+          "name": "firearm_photo_firearm_id_firearm_id_fk",
+          "tableFrom": "firearm_photo",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "firearm_photo_sort_order_min": {
+          "name": "firearm_photo_sort_order_min",
+          "value": "\"firearm_photo\".\"sort_order\" >= 0"
+        },
+        "firearm_photo_mime_type_valid": {
+          "name": "firearm_photo_mime_type_valid",
+          "value": "\"firearm_photo\".\"mime_type\" in ('image/jpeg', 'image/png', 'image/webp', 'image/avif')"
+        },
+        "firearm_photo_size_bytes_min": {
+          "name": "firearm_photo_size_bytes_min",
+          "value": "\"firearm_photo\".\"size_bytes\" > 0"
+        },
+        "firearm_photo_width_min": {
+          "name": "firearm_photo_width_min",
+          "value": "\"firearm_photo\".\"width\" > 0"
+        },
+        "firearm_photo_height_min": {
+          "name": "firearm_photo_height_min",
+          "value": "\"firearm_photo\".\"height\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.grant": {
+      "name": "grant",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "grantee_id": {
+          "name": "grantee_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_type": {
+          "name": "parent_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_id": {
+          "name": "parent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "permission": {
+          "name": "permission",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "allow_create_on_behalf": {
+          "name": "allow_create_on_behalf",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "grant_grantee_parent_type_idx": {
+          "name": "grant_grantee_parent_type_idx",
+          "columns": [
+            {
+              "expression": "grantee_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "parent_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "grant_owner_id_user_id_fk": {
+          "name": "grant_owner_id_user_id_fk",
+          "tableFrom": "grant",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "grant_grantee_id_user_id_fk": {
+          "name": "grant_grantee_id_user_id_fk",
+          "tableFrom": "grant",
+          "tableTo": "user",
+          "columnsFrom": ["grantee_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "grant_grantee_parent_unique": {
+          "name": "grant_grantee_parent_unique",
+          "nullsNotDistinct": false,
+          "columns": ["grantee_id", "parent_type", "parent_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "grant_parent_type_valid": {
+          "name": "grant_parent_type_valid",
+          "value": "\"grant\".\"parent_type\" in ('firearm', 'magazine', 'ammo')"
+        },
+        "grant_permission_valid": {
+          "name": "grant_permission_valid",
+          "value": "\"grant\".\"permission\" in ('view', 'edit')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.idempotency": {
+      "name": "idempotency",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "result": {
+          "name": "result",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idempotency_expires_at_idx": {
+          "name": "idempotency_expires_at_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "idempotency_user_id_user_id_fk": {
+          "name": "idempotency_user_id_user_id_fk",
+          "tableFrom": "idempotency",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "idempotency_user_id_idempotency_key_pk": {
+          "name": "idempotency_user_id_idempotency_key_pk",
+          "columns": ["user_id", "idempotency_key"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.inventory_log": {
+      "name": "inventory_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "parent_type": {
+          "name": "parent_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_id": {
+          "name": "parent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "event_type": {
+          "name": "event_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "occurred_at": {
+          "name": "occurred_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "inventory_log_parent_idx": {
+          "name": "inventory_log_parent_idx",
+          "columns": [
+            {
+              "expression": "parent_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "parent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "occurred_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "inventory_log_actor_id_user_id_fk": {
+          "name": "inventory_log_actor_id_user_id_fk",
+          "tableFrom": "inventory_log",
+          "tableTo": "user",
+          "columnsFrom": ["actor_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "inventory_log_parent_type_valid": {
+          "name": "inventory_log_parent_type_valid",
+          "value": "\"inventory_log\".\"parent_type\" in ('firearm', 'magazine')"
+        },
+        "inventory_log_event_type_valid": {
+          "name": "inventory_log_event_type_valid",
+          "value": "(\"inventory_log\".\"parent_type\" = 'firearm' AND \"inventory_log\".\"event_type\" in ('inventoried', 'cleaned', 'lubed')) OR (\"inventory_log\".\"parent_type\" = 'magazine' AND \"inventory_log\".\"event_type\" in ('inventoried'))"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.magazine": {
+      "name": "magazine",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "brand_model": {
+          "name": "brand_model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "caliber": {
+          "name": "caliber",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "base_capacity": {
+          "name": "base_capacity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "extension_rounds": {
+          "name": "extension_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "acquired_date": {
+          "name": "acquired_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "magazine_owner_id_idx": {
+          "name": "magazine_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "magazine_owner_id_user_id_fk": {
+          "name": "magazine_owner_id_user_id_fk",
+          "tableFrom": "magazine",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "magazine_base_capacity_min": {
+          "name": "magazine_base_capacity_min",
+          "value": "\"magazine\".\"base_capacity\" >= 1"
+        },
+        "magazine_extension_rounds_min": {
+          "name": "magazine_extension_rounds_min",
+          "value": "\"magazine\".\"extension_rounds\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.magazine_firearm": {
+      "name": "magazine_firearm",
+      "schema": "",
+      "columns": {
+        "magazine_id": {
+          "name": "magazine_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ordinal": {
+          "name": "ordinal",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "magazine_firearm_firearm_id_idx": {
+          "name": "magazine_firearm_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "magazine_firearm_magazine_id_magazine_id_fk": {
+          "name": "magazine_firearm_magazine_id_magazine_id_fk",
+          "tableFrom": "magazine_firearm",
+          "tableTo": "magazine",
+          "columnsFrom": ["magazine_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "magazine_firearm_firearm_id_firearm_id_fk": {
+          "name": "magazine_firearm_firearm_id_firearm_id_fk",
+          "tableFrom": "magazine_firearm",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "magazine_firearm_magazine_id_firearm_id_pk": {
+          "name": "magazine_firearm_magazine_id_firearm_id_pk",
+          "columns": ["magazine_id", "firearm_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.magazine_label_prefix": {
+      "name": "magazine_label_prefix",
+      "schema": "",
+      "columns": {
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "magazine_label_prefix_owner_id_user_id_fk": {
+          "name": "magazine_label_prefix_owner_id_user_id_fk",
+          "tableFrom": "magazine_label_prefix",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "magazine_label_prefix_owner_id_prefix_pk": {
+          "name": "magazine_label_prefix_owner_id_prefix_pk",
+          "columns": ["owner_id", "prefix"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.range_session": {
+      "name": "range_session",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "date": {
+          "name": "date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rounds_fired": {
+          "name": "rounds_fired",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ammo_id": {
+          "name": "ammo_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "range_session_firearm_id_idx": {
+          "name": "range_session_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "range_session_firearm_id_firearm_id_fk": {
+          "name": "range_session_firearm_id_firearm_id_fk",
+          "tableFrom": "range_session",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "range_session_rounds_fired_min": {
+          "name": "range_session_rounds_fired_min",
+          "value": "\"range_session\".\"rounds_fired\" >= 1"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.range_session_accessory": {
+      "name": "range_session_accessory",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "range_session_id": {
+          "name": "range_session_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "accessory_id": {
+          "name": "accessory_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "range_session_accessory_session_id_idx": {
+          "name": "range_session_accessory_session_id_idx",
+          "columns": [
+            {
+              "expression": "range_session_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "range_session_accessory_accessory_id_idx": {
+          "name": "range_session_accessory_accessory_id_idx",
+          "columns": [
+            {
+              "expression": "accessory_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "range_session_accessory_range_session_id_range_session_id_fk": {
+          "name": "range_session_accessory_range_session_id_range_session_id_fk",
+          "tableFrom": "range_session_accessory",
+          "tableTo": "range_session",
+          "columnsFrom": ["range_session_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "range_session_accessory_accessory_id_accessory_id_fk": {
+          "name": "range_session_accessory_accessory_id_accessory_id_fk",
+          "tableFrom": "range_session_accessory",
+          "tableTo": "accessory",
+          "columnsFrom": ["accessory_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "range_session_accessory_unique": {
+          "name": "range_session_accessory_unique",
+          "nullsNotDistinct": false,
+          "columns": ["range_session_id", "accessory_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.service_event": {
+      "name": "service_event",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "accessory_id": {
+          "name": "accessory_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rule_name": {
+          "name": "rule_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serviced_on": {
+          "name": "serviced_on",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "service_event_firearm_id_idx": {
+          "name": "service_event_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "service_event_accessory_id_idx": {
+          "name": "service_event_accessory_id_idx",
+          "columns": [
+            {
+              "expression": "accessory_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "service_event_firearm_rule_serviced_idx": {
+          "name": "service_event_firearm_rule_serviced_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "rule_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "serviced_on",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "service_event_accessory_rule_serviced_idx": {
+          "name": "service_event_accessory_rule_serviced_idx",
+          "columns": [
+            {
+              "expression": "accessory_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "rule_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "serviced_on",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "service_event_firearm_id_firearm_id_fk": {
+          "name": "service_event_firearm_id_firearm_id_fk",
+          "tableFrom": "service_event",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "service_event_accessory_id_accessory_id_fk": {
+          "name": "service_event_accessory_id_accessory_id_fk",
+          "tableFrom": "service_event",
+          "tableTo": "accessory",
+          "columnsFrom": ["accessory_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "service_event_actor_id_user_id_fk": {
+          "name": "service_event_actor_id_user_id_fk",
+          "tableFrom": "service_event",
+          "tableTo": "user",
+          "columnsFrom": ["actor_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "service_event_exactly_one_parent": {
+          "name": "service_event_exactly_one_parent",
+          "value": "num_nonnulls(\"service_event\".\"firearm_id\", \"service_event\".\"accessory_id\") = 1"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.service_rule": {
+      "name": "service_rule",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "accessory_id": {
+          "name": "accessory_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "suppressed": {
+          "name": "suppressed",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "interval_days": {
+          "name": "interval_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "interval_sessions": {
+          "name": "interval_sessions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "interval_rounds": {
+          "name": "interval_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "service_rule_firearm_id_idx": {
+          "name": "service_rule_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "service_rule_accessory_id_idx": {
+          "name": "service_rule_accessory_id_idx",
+          "columns": [
+            {
+              "expression": "accessory_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "service_rule_firearm_id_firearm_id_fk": {
+          "name": "service_rule_firearm_id_firearm_id_fk",
+          "tableFrom": "service_rule",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "service_rule_accessory_id_accessory_id_fk": {
+          "name": "service_rule_accessory_id_accessory_id_fk",
+          "tableFrom": "service_rule",
+          "tableTo": "accessory",
+          "columnsFrom": ["accessory_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "service_rule_firearm_name_unique": {
+          "name": "service_rule_firearm_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["firearm_id", "name"]
+        },
+        "service_rule_accessory_name_unique": {
+          "name": "service_rule_accessory_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["accessory_id", "name"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "service_rule_exactly_one_parent": {
+          "name": "service_rule_exactly_one_parent",
+          "value": "num_nonnulls(\"service_rule\".\"firearm_id\", \"service_rule\".\"accessory_id\") = 1"
+        },
+        "service_rule_thresholds_min": {
+          "name": "service_rule_thresholds_min",
+          "value": "(\"service_rule\".\"interval_days\" IS NULL OR \"service_rule\".\"interval_days\" >= 1) AND (\"service_rule\".\"interval_sessions\" IS NULL OR \"service_rule\".\"interval_sessions\" >= 1) AND (\"service_rule\".\"interval_rounds\" IS NULL OR \"service_rule\".\"interval_rounds\" >= 1)"
+        },
+        "service_rule_suppressed_thresholds_consistent": {
+          "name": "service_rule_suppressed_thresholds_consistent",
+          "value": "(\"service_rule\".\"suppressed\" AND num_nonnulls(\"service_rule\".\"interval_days\", \"service_rule\".\"interval_sessions\", \"service_rule\".\"interval_rounds\") = 0) OR (NOT \"service_rule\".\"suppressed\" AND num_nonnulls(\"service_rule\".\"interval_days\", \"service_rule\".\"interval_sessions\", \"service_rule\".\"interval_rounds\") >= 1)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.service_rule_default": {
+      "name": "service_rule_default",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "interval_days": {
+          "name": "interval_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "interval_sessions": {
+          "name": "interval_sessions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "interval_rounds": {
+          "name": "interval_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "service_rule_default_owner_id_idx": {
+          "name": "service_rule_default_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "service_rule_default_owner_id_user_id_fk": {
+          "name": "service_rule_default_owner_id_user_id_fk",
+          "tableFrom": "service_rule_default",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "service_rule_default_owner_scope_category_name_unique": {
+          "name": "service_rule_default_owner_scope_category_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["owner_id", "scope", "category", "name"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "service_rule_default_scope_valid": {
+          "name": "service_rule_default_scope_valid",
+          "value": "\"service_rule_default\".\"scope\" in ('firearm', 'accessory')"
+        },
+        "service_rule_default_has_threshold": {
+          "name": "service_rule_default_has_threshold",
+          "value": "num_nonnulls(\"service_rule_default\".\"interval_days\", \"service_rule_default\".\"interval_sessions\", \"service_rule_default\".\"interval_rounds\") >= 1"
+        },
+        "service_rule_default_thresholds_min": {
+          "name": "service_rule_default_thresholds_min",
+          "value": "(\"service_rule_default\".\"interval_days\" IS NULL OR \"service_rule_default\".\"interval_days\" >= 1) AND (\"service_rule_default\".\"interval_sessions\" IS NULL OR \"service_rule_default\".\"interval_sessions\" >= 1) AND (\"service_rule_default\".\"interval_rounds\" IS NULL OR \"service_rule_default\".\"interval_rounds\" >= 1)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.operator_audit": {
+      "name": "operator_audit",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "actor": {
+          "name": "actor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "outcome": {
+          "name": "outcome",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "at": {
+          "name": "at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "operator_audit_at_idx": {
+          "name": "operator_audit_at_idx",
+          "columns": [
+            {
+              "expression": "at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "operator_audit_action_valid": {
+          "name": "operator_audit_action_valid",
+          "value": "\"operator_audit\".\"action\" in ('export', 'restore')"
+        }
+      },
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
diff --git a/src/db/migrations/meta/0020_snapshot.json b/src/db/migrations/meta/0020_snapshot.json
new file mode 100644
index 00000000..05933058
--- /dev/null
+++ b/src/db/migrations/meta/0020_snapshot.json
@@ -0,0 +1,2388 @@
+{
+  "id": "af69dd32-c94f-4963-8ae9-e962816c3776",
+  "prevId": "4d0317eb-cca4-4124-84d7-c5091af0a3cf",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.account": {
+      "name": "account",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "id_token": {
+          "name": "id_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_token_expires_at": {
+          "name": "access_token_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token_expires_at": {
+          "name": "refresh_token_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "account_userId_idx": {
+          "name": "account_userId_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "account_user_id_user_id_fk": {
+          "name": "account_user_id_user_id_fk",
+          "tableFrom": "account",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.rate_limit": {
+      "name": "rate_limit",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "count": {
+          "name": "count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_request": {
+          "name": "last_request",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "rate_limit_key_unique": {
+          "name": "rate_limit_key_unique",
+          "nullsNotDistinct": false,
+          "columns": ["key"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.session": {
+      "name": "session",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token": {
+          "name": "token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "impersonated_by": {
+          "name": "impersonated_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "session_userId_idx": {
+          "name": "session_userId_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "session_user_id_user_id_fk": {
+          "name": "session_user_id_user_id_fk",
+          "tableFrom": "session",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "session_token_unique": {
+          "name": "session_token_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user": {
+      "name": "user",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email_verified": {
+          "name": "email_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "image": {
+          "name": "image",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "banned": {
+          "name": "banned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "ban_reason": {
+          "name": "ban_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ban_expires": {
+          "name": "ban_expires",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "magpul_mode": {
+          "name": "magpul_mode",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "user_email_unique": {
+          "name": "user_email_unique",
+          "nullsNotDistinct": false,
+          "columns": ["email"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.verification": {
+      "name": "verification",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "identifier": {
+          "name": "identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "verification_identifier_idx": {
+          "name": "verification_identifier_idx",
+          "columns": [
+            {
+              "expression": "identifier",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.accessory": {
+      "name": "accessory",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "current_firearm_id": {
+          "name": "current_firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "brand": {
+          "name": "brand",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "serial_number": {
+          "name": "serial_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "installed_date": {
+          "name": "installed_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cost_cents": {
+          "name": "cost_cents",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "is_nfa": {
+          "name": "is_nfa",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "accessory_owner_id_idx": {
+          "name": "accessory_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "accessory_current_firearm_id_idx": {
+          "name": "accessory_current_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "current_firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "accessory_owner_id_user_id_fk": {
+          "name": "accessory_owner_id_user_id_fk",
+          "tableFrom": "accessory",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "accessory_current_firearm_id_firearm_id_fk": {
+          "name": "accessory_current_firearm_id_firearm_id_fk",
+          "tableFrom": "accessory",
+          "tableTo": "firearm",
+          "columnsFrom": ["current_firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "accessory_cost_cents_min": {
+          "name": "accessory_cost_cents_min",
+          "value": "\"accessory\".\"cost_cents\" >= 0"
+        },
+        "accessory_installed_date_requires_mount": {
+          "name": "accessory_installed_date_requires_mount",
+          "value": "\"accessory\".\"installed_date\" IS NULL OR \"accessory\".\"current_firearm_id\" IS NOT NULL"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.ammo": {
+      "name": "ammo",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "brand": {
+          "name": "brand",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "caliber": {
+          "name": "caliber",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "grain": {
+          "name": "grain",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "quantity_rounds": {
+          "name": "quantity_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "low_stock_threshold": {
+          "name": "low_stock_threshold",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "acquired_date": {
+          "name": "acquired_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "ammo_owner_id_idx": {
+          "name": "ammo_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "ammo_owner_id_user_id_fk": {
+          "name": "ammo_owner_id_user_id_fk",
+          "tableFrom": "ammo",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "ammo_grain_min": {
+          "name": "ammo_grain_min",
+          "value": "\"ammo\".\"grain\" >= 0"
+        },
+        "ammo_quantity_min": {
+          "name": "ammo_quantity_min",
+          "value": "\"ammo\".\"quantity_rounds\" >= 0"
+        },
+        "ammo_threshold_min": {
+          "name": "ammo_threshold_min",
+          "value": "\"ammo\".\"low_stock_threshold\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.firearm": {
+      "name": "firearm",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "nickname": {
+          "name": "nickname",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "manufacturer": {
+          "name": "manufacturer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "caliber": {
+          "name": "caliber",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'unspecified'"
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'unspecified'"
+        },
+        "subtype": {
+          "name": "subtype",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "serial_number": {
+          "name": "serial_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "is_nfa": {
+          "name": "is_nfa",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "acquired_date": {
+          "name": "acquired_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "firearm_owner_id_idx": {
+          "name": "firearm_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "firearm_owner_id_user_id_fk": {
+          "name": "firearm_owner_id_user_id_fk",
+          "tableFrom": "firearm",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "firearm_type_valid": {
+          "name": "firearm_type_valid",
+          "value": "\"firearm\".\"type\" in ('pistol', 'revolver', 'rifle', 'shotgun', 'pcc', 'other', 'unspecified')"
+        },
+        "firearm_action_valid": {
+          "name": "firearm_action_valid",
+          "value": "\"firearm\".\"action\" in ('semi-auto', 'bolt', 'lever', 'pump', 'break', 'single-shot', 'unspecified')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.firearm_document": {
+      "name": "firearm_document",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "storage_key": {
+          "name": "storage_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "filename": {
+          "name": "filename",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size_bytes": {
+          "name": "size_bytes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "doc_type": {
+          "name": "doc_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'other'"
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "uploaded_at": {
+          "name": "uploaded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "firearm_document_firearm_id_idx": {
+          "name": "firearm_document_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "firearm_document_firearm_id_firearm_id_fk": {
+          "name": "firearm_document_firearm_id_firearm_id_fk",
+          "tableFrom": "firearm_document",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "firearm_document_mime_type_valid": {
+          "name": "firearm_document_mime_type_valid",
+          "value": "\"firearm_document\".\"mime_type\" in ('application/pdf', 'image/jpeg', 'image/png', 'image/webp', 'image/avif')"
+        },
+        "firearm_document_doc_type_valid": {
+          "name": "firearm_document_doc_type_valid",
+          "value": "\"firearm_document\".\"doc_type\" in ('receipt', 'warranty', 'atf-form-1', 'atf-form-4', 'manual', 'insurance', 'other')"
+        },
+        "firearm_document_size_bytes_min": {
+          "name": "firearm_document_size_bytes_min",
+          "value": "\"firearm_document\".\"size_bytes\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.firearm_photo": {
+      "name": "firearm_photo",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "storage_key": {
+          "name": "storage_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size_bytes": {
+          "name": "size_bytes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "width": {
+          "name": "width",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "height": {
+          "name": "height",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "caption": {
+          "name": "caption",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_primary": {
+          "name": "is_primary",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "uploaded_at": {
+          "name": "uploaded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "firearm_photo_firearm_id_idx": {
+          "name": "firearm_photo_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "firearm_photo_one_primary_per_firearm": {
+          "name": "firearm_photo_one_primary_per_firearm",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"firearm_photo\".\"is_primary\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "firearm_photo_firearm_id_firearm_id_fk": {
+          "name": "firearm_photo_firearm_id_firearm_id_fk",
+          "tableFrom": "firearm_photo",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "firearm_photo_sort_order_min": {
+          "name": "firearm_photo_sort_order_min",
+          "value": "\"firearm_photo\".\"sort_order\" >= 0"
+        },
+        "firearm_photo_mime_type_valid": {
+          "name": "firearm_photo_mime_type_valid",
+          "value": "\"firearm_photo\".\"mime_type\" in ('image/jpeg', 'image/png', 'image/webp', 'image/avif')"
+        },
+        "firearm_photo_size_bytes_min": {
+          "name": "firearm_photo_size_bytes_min",
+          "value": "\"firearm_photo\".\"size_bytes\" > 0"
+        },
+        "firearm_photo_width_min": {
+          "name": "firearm_photo_width_min",
+          "value": "\"firearm_photo\".\"width\" > 0"
+        },
+        "firearm_photo_height_min": {
+          "name": "firearm_photo_height_min",
+          "value": "\"firearm_photo\".\"height\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.grant": {
+      "name": "grant",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "grantee_id": {
+          "name": "grantee_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_type": {
+          "name": "parent_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_id": {
+          "name": "parent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "permission": {
+          "name": "permission",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "allow_create_on_behalf": {
+          "name": "allow_create_on_behalf",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "grant_grantee_parent_type_idx": {
+          "name": "grant_grantee_parent_type_idx",
+          "columns": [
+            {
+              "expression": "grantee_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "parent_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "grant_owner_id_user_id_fk": {
+          "name": "grant_owner_id_user_id_fk",
+          "tableFrom": "grant",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "grant_grantee_id_user_id_fk": {
+          "name": "grant_grantee_id_user_id_fk",
+          "tableFrom": "grant",
+          "tableTo": "user",
+          "columnsFrom": ["grantee_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "grant_grantee_parent_unique": {
+          "name": "grant_grantee_parent_unique",
+          "nullsNotDistinct": false,
+          "columns": ["grantee_id", "parent_type", "parent_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "grant_parent_type_valid": {
+          "name": "grant_parent_type_valid",
+          "value": "\"grant\".\"parent_type\" in ('firearm', 'magazine', 'ammo')"
+        },
+        "grant_permission_valid": {
+          "name": "grant_permission_valid",
+          "value": "\"grant\".\"permission\" in ('view', 'edit')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.idempotency": {
+      "name": "idempotency",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "result": {
+          "name": "result",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idempotency_expires_at_idx": {
+          "name": "idempotency_expires_at_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "idempotency_user_id_user_id_fk": {
+          "name": "idempotency_user_id_user_id_fk",
+          "tableFrom": "idempotency",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "idempotency_user_id_idempotency_key_pk": {
+          "name": "idempotency_user_id_idempotency_key_pk",
+          "columns": ["user_id", "idempotency_key"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.inventory_log": {
+      "name": "inventory_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "parent_type": {
+          "name": "parent_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_id": {
+          "name": "parent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "event_type": {
+          "name": "event_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "occurred_at": {
+          "name": "occurred_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "inventory_log_parent_idx": {
+          "name": "inventory_log_parent_idx",
+          "columns": [
+            {
+              "expression": "parent_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "parent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "occurred_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "inventory_log_actor_id_user_id_fk": {
+          "name": "inventory_log_actor_id_user_id_fk",
+          "tableFrom": "inventory_log",
+          "tableTo": "user",
+          "columnsFrom": ["actor_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "inventory_log_parent_type_valid": {
+          "name": "inventory_log_parent_type_valid",
+          "value": "\"inventory_log\".\"parent_type\" in ('firearm', 'magazine')"
+        },
+        "inventory_log_event_type_valid": {
+          "name": "inventory_log_event_type_valid",
+          "value": "(\"inventory_log\".\"parent_type\" = 'firearm' AND \"inventory_log\".\"event_type\" in ('inventoried')) OR (\"inventory_log\".\"parent_type\" = 'magazine' AND \"inventory_log\".\"event_type\" in ('inventoried'))"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.magazine": {
+      "name": "magazine",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "brand_model": {
+          "name": "brand_model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "caliber": {
+          "name": "caliber",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "base_capacity": {
+          "name": "base_capacity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "extension_rounds": {
+          "name": "extension_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "acquired_date": {
+          "name": "acquired_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "magazine_owner_id_idx": {
+          "name": "magazine_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "magazine_owner_id_user_id_fk": {
+          "name": "magazine_owner_id_user_id_fk",
+          "tableFrom": "magazine",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "magazine_base_capacity_min": {
+          "name": "magazine_base_capacity_min",
+          "value": "\"magazine\".\"base_capacity\" >= 1"
+        },
+        "magazine_extension_rounds_min": {
+          "name": "magazine_extension_rounds_min",
+          "value": "\"magazine\".\"extension_rounds\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.magazine_firearm": {
+      "name": "magazine_firearm",
+      "schema": "",
+      "columns": {
+        "magazine_id": {
+          "name": "magazine_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ordinal": {
+          "name": "ordinal",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "magazine_firearm_firearm_id_idx": {
+          "name": "magazine_firearm_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "magazine_firearm_magazine_id_magazine_id_fk": {
+          "name": "magazine_firearm_magazine_id_magazine_id_fk",
+          "tableFrom": "magazine_firearm",
+          "tableTo": "magazine",
+          "columnsFrom": ["magazine_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "magazine_firearm_firearm_id_firearm_id_fk": {
+          "name": "magazine_firearm_firearm_id_firearm_id_fk",
+          "tableFrom": "magazine_firearm",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "magazine_firearm_magazine_id_firearm_id_pk": {
+          "name": "magazine_firearm_magazine_id_firearm_id_pk",
+          "columns": ["magazine_id", "firearm_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.magazine_label_prefix": {
+      "name": "magazine_label_prefix",
+      "schema": "",
+      "columns": {
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "magazine_label_prefix_owner_id_user_id_fk": {
+          "name": "magazine_label_prefix_owner_id_user_id_fk",
+          "tableFrom": "magazine_label_prefix",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "magazine_label_prefix_owner_id_prefix_pk": {
+          "name": "magazine_label_prefix_owner_id_prefix_pk",
+          "columns": ["owner_id", "prefix"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.range_session": {
+      "name": "range_session",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "date": {
+          "name": "date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rounds_fired": {
+          "name": "rounds_fired",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ammo_id": {
+          "name": "ammo_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "range_session_firearm_id_idx": {
+          "name": "range_session_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "range_session_firearm_id_firearm_id_fk": {
+          "name": "range_session_firearm_id_firearm_id_fk",
+          "tableFrom": "range_session",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "range_session_rounds_fired_min": {
+          "name": "range_session_rounds_fired_min",
+          "value": "\"range_session\".\"rounds_fired\" >= 1"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.range_session_accessory": {
+      "name": "range_session_accessory",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "range_session_id": {
+          "name": "range_session_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "accessory_id": {
+          "name": "accessory_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "range_session_accessory_session_id_idx": {
+          "name": "range_session_accessory_session_id_idx",
+          "columns": [
+            {
+              "expression": "range_session_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "range_session_accessory_accessory_id_idx": {
+          "name": "range_session_accessory_accessory_id_idx",
+          "columns": [
+            {
+              "expression": "accessory_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "range_session_accessory_range_session_id_range_session_id_fk": {
+          "name": "range_session_accessory_range_session_id_range_session_id_fk",
+          "tableFrom": "range_session_accessory",
+          "tableTo": "range_session",
+          "columnsFrom": ["range_session_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "range_session_accessory_accessory_id_accessory_id_fk": {
+          "name": "range_session_accessory_accessory_id_accessory_id_fk",
+          "tableFrom": "range_session_accessory",
+          "tableTo": "accessory",
+          "columnsFrom": ["accessory_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "range_session_accessory_unique": {
+          "name": "range_session_accessory_unique",
+          "nullsNotDistinct": false,
+          "columns": ["range_session_id", "accessory_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.service_event": {
+      "name": "service_event",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "accessory_id": {
+          "name": "accessory_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rule_name": {
+          "name": "rule_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serviced_on": {
+          "name": "serviced_on",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "service_event_firearm_id_idx": {
+          "name": "service_event_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "service_event_accessory_id_idx": {
+          "name": "service_event_accessory_id_idx",
+          "columns": [
+            {
+              "expression": "accessory_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "service_event_firearm_rule_serviced_idx": {
+          "name": "service_event_firearm_rule_serviced_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "rule_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "serviced_on",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "service_event_accessory_rule_serviced_idx": {
+          "name": "service_event_accessory_rule_serviced_idx",
+          "columns": [
+            {
+              "expression": "accessory_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "rule_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "serviced_on",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "service_event_firearm_id_firearm_id_fk": {
+          "name": "service_event_firearm_id_firearm_id_fk",
+          "tableFrom": "service_event",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "service_event_accessory_id_accessory_id_fk": {
+          "name": "service_event_accessory_id_accessory_id_fk",
+          "tableFrom": "service_event",
+          "tableTo": "accessory",
+          "columnsFrom": ["accessory_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "service_event_actor_id_user_id_fk": {
+          "name": "service_event_actor_id_user_id_fk",
+          "tableFrom": "service_event",
+          "tableTo": "user",
+          "columnsFrom": ["actor_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "service_event_exactly_one_parent": {
+          "name": "service_event_exactly_one_parent",
+          "value": "num_nonnulls(\"service_event\".\"firearm_id\", \"service_event\".\"accessory_id\") = 1"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.service_rule": {
+      "name": "service_rule",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "accessory_id": {
+          "name": "accessory_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "suppressed": {
+          "name": "suppressed",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "interval_days": {
+          "name": "interval_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "interval_sessions": {
+          "name": "interval_sessions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "interval_rounds": {
+          "name": "interval_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "service_rule_firearm_id_idx": {
+          "name": "service_rule_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "service_rule_accessory_id_idx": {
+          "name": "service_rule_accessory_id_idx",
+          "columns": [
+            {
+              "expression": "accessory_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "service_rule_firearm_id_firearm_id_fk": {
+          "name": "service_rule_firearm_id_firearm_id_fk",
+          "tableFrom": "service_rule",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "service_rule_accessory_id_accessory_id_fk": {
+          "name": "service_rule_accessory_id_accessory_id_fk",
+          "tableFrom": "service_rule",
+          "tableTo": "accessory",
+          "columnsFrom": ["accessory_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "service_rule_firearm_name_unique": {
+          "name": "service_rule_firearm_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["firearm_id", "name"]
+        },
+        "service_rule_accessory_name_unique": {
+          "name": "service_rule_accessory_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["accessory_id", "name"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "service_rule_exactly_one_parent": {
+          "name": "service_rule_exactly_one_parent",
+          "value": "num_nonnulls(\"service_rule\".\"firearm_id\", \"service_rule\".\"accessory_id\") = 1"
+        },
+        "service_rule_thresholds_min": {
+          "name": "service_rule_thresholds_min",
+          "value": "(\"service_rule\".\"interval_days\" IS NULL OR \"service_rule\".\"interval_days\" >= 1) AND (\"service_rule\".\"interval_sessions\" IS NULL OR \"service_rule\".\"interval_sessions\" >= 1) AND (\"service_rule\".\"interval_rounds\" IS NULL OR \"service_rule\".\"interval_rounds\" >= 1)"
+        },
+        "service_rule_suppressed_thresholds_consistent": {
+          "name": "service_rule_suppressed_thresholds_consistent",
+          "value": "(\"service_rule\".\"suppressed\" AND num_nonnulls(\"service_rule\".\"interval_days\", \"service_rule\".\"interval_sessions\", \"service_rule\".\"interval_rounds\") = 0) OR (NOT \"service_rule\".\"suppressed\" AND num_nonnulls(\"service_rule\".\"interval_days\", \"service_rule\".\"interval_sessions\", \"service_rule\".\"interval_rounds\") >= 1)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.service_rule_default": {
+      "name": "service_rule_default",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "interval_days": {
+          "name": "interval_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "interval_sessions": {
+          "name": "interval_sessions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "interval_rounds": {
+          "name": "interval_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "service_rule_default_owner_id_idx": {
+          "name": "service_rule_default_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "service_rule_default_owner_id_user_id_fk": {
+          "name": "service_rule_default_owner_id_user_id_fk",
+          "tableFrom": "service_rule_default",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "service_rule_default_owner_scope_category_name_unique": {
+          "name": "service_rule_default_owner_scope_category_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["owner_id", "scope", "category", "name"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "service_rule_default_scope_valid": {
+          "name": "service_rule_default_scope_valid",
+          "value": "\"service_rule_default\".\"scope\" in ('firearm', 'accessory')"
+        },
+        "service_rule_default_has_threshold": {
+          "name": "service_rule_default_has_threshold",
+          "value": "num_nonnulls(\"service_rule_default\".\"interval_days\", \"service_rule_default\".\"interval_sessions\", \"service_rule_default\".\"interval_rounds\") >= 1"
+        },
+        "service_rule_default_thresholds_min": {
+          "name": "service_rule_default_thresholds_min",
+          "value": "(\"service_rule_default\".\"interval_days\" IS NULL OR \"service_rule_default\".\"interval_days\" >= 1) AND (\"service_rule_default\".\"interval_sessions\" IS NULL OR \"service_rule_default\".\"interval_sessions\" >= 1) AND (\"service_rule_default\".\"interval_rounds\" IS NULL OR \"service_rule_default\".\"interval_rounds\" >= 1)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.operator_audit": {
+      "name": "operator_audit",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "actor": {
+          "name": "actor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "outcome": {
+          "name": "outcome",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "at": {
+          "name": "at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "operator_audit_at_idx": {
+          "name": "operator_audit_at_idx",
+          "columns": [
+            {
+              "expression": "at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "operator_audit_action_valid": {
+          "name": "operator_audit_action_valid",
+          "value": "\"operator_audit\".\"action\" in ('export', 'restore')"
+        }
+      },
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
diff --git a/src/db/migrations/meta/0021_snapshot.json b/src/db/migrations/meta/0021_snapshot.json
new file mode 100644
index 00000000..f009bd86
--- /dev/null
+++ b/src/db/migrations/meta/0021_snapshot.json
@@ -0,0 +1,2394 @@
+{
+  "id": "a872c107-6e22-4fbb-a56c-ee950a53df62",
+  "prevId": "af69dd32-c94f-4963-8ae9-e962816c3776",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.account": {
+      "name": "account",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "id_token": {
+          "name": "id_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_token_expires_at": {
+          "name": "access_token_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token_expires_at": {
+          "name": "refresh_token_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "account_userId_idx": {
+          "name": "account_userId_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "account_user_id_user_id_fk": {
+          "name": "account_user_id_user_id_fk",
+          "tableFrom": "account",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.rate_limit": {
+      "name": "rate_limit",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "count": {
+          "name": "count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_request": {
+          "name": "last_request",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "rate_limit_key_unique": {
+          "name": "rate_limit_key_unique",
+          "nullsNotDistinct": false,
+          "columns": ["key"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.session": {
+      "name": "session",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token": {
+          "name": "token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "impersonated_by": {
+          "name": "impersonated_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "session_userId_idx": {
+          "name": "session_userId_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "session_user_id_user_id_fk": {
+          "name": "session_user_id_user_id_fk",
+          "tableFrom": "session",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "session_token_unique": {
+          "name": "session_token_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user": {
+      "name": "user",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email_verified": {
+          "name": "email_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "image": {
+          "name": "image",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "banned": {
+          "name": "banned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "ban_reason": {
+          "name": "ban_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ban_expires": {
+          "name": "ban_expires",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "magpul_mode": {
+          "name": "magpul_mode",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "user_email_unique": {
+          "name": "user_email_unique",
+          "nullsNotDistinct": false,
+          "columns": ["email"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.verification": {
+      "name": "verification",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "identifier": {
+          "name": "identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "verification_identifier_idx": {
+          "name": "verification_identifier_idx",
+          "columns": [
+            {
+              "expression": "identifier",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.accessory": {
+      "name": "accessory",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "current_firearm_id": {
+          "name": "current_firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "brand": {
+          "name": "brand",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "serial_number": {
+          "name": "serial_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "installed_date": {
+          "name": "installed_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "acquired_date": {
+          "name": "acquired_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cost_cents": {
+          "name": "cost_cents",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "is_nfa": {
+          "name": "is_nfa",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "accessory_owner_id_idx": {
+          "name": "accessory_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "accessory_current_firearm_id_idx": {
+          "name": "accessory_current_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "current_firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "accessory_owner_id_user_id_fk": {
+          "name": "accessory_owner_id_user_id_fk",
+          "tableFrom": "accessory",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "accessory_current_firearm_id_firearm_id_fk": {
+          "name": "accessory_current_firearm_id_firearm_id_fk",
+          "tableFrom": "accessory",
+          "tableTo": "firearm",
+          "columnsFrom": ["current_firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "accessory_cost_cents_min": {
+          "name": "accessory_cost_cents_min",
+          "value": "\"accessory\".\"cost_cents\" >= 0"
+        },
+        "accessory_installed_date_requires_mount": {
+          "name": "accessory_installed_date_requires_mount",
+          "value": "\"accessory\".\"installed_date\" IS NULL OR \"accessory\".\"current_firearm_id\" IS NOT NULL"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.ammo": {
+      "name": "ammo",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "brand": {
+          "name": "brand",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "caliber": {
+          "name": "caliber",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "grain": {
+          "name": "grain",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "quantity_rounds": {
+          "name": "quantity_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "low_stock_threshold": {
+          "name": "low_stock_threshold",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "acquired_date": {
+          "name": "acquired_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "ammo_owner_id_idx": {
+          "name": "ammo_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "ammo_owner_id_user_id_fk": {
+          "name": "ammo_owner_id_user_id_fk",
+          "tableFrom": "ammo",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "ammo_grain_min": {
+          "name": "ammo_grain_min",
+          "value": "\"ammo\".\"grain\" >= 0"
+        },
+        "ammo_quantity_min": {
+          "name": "ammo_quantity_min",
+          "value": "\"ammo\".\"quantity_rounds\" >= 0"
+        },
+        "ammo_threshold_min": {
+          "name": "ammo_threshold_min",
+          "value": "\"ammo\".\"low_stock_threshold\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.firearm": {
+      "name": "firearm",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "nickname": {
+          "name": "nickname",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "manufacturer": {
+          "name": "manufacturer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "caliber": {
+          "name": "caliber",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'unspecified'"
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'unspecified'"
+        },
+        "subtype": {
+          "name": "subtype",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "serial_number": {
+          "name": "serial_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "is_nfa": {
+          "name": "is_nfa",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "acquired_date": {
+          "name": "acquired_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "firearm_owner_id_idx": {
+          "name": "firearm_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "firearm_owner_id_user_id_fk": {
+          "name": "firearm_owner_id_user_id_fk",
+          "tableFrom": "firearm",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "firearm_type_valid": {
+          "name": "firearm_type_valid",
+          "value": "\"firearm\".\"type\" in ('pistol', 'revolver', 'rifle', 'shotgun', 'pcc', 'other', 'unspecified')"
+        },
+        "firearm_action_valid": {
+          "name": "firearm_action_valid",
+          "value": "\"firearm\".\"action\" in ('semi-auto', 'bolt', 'lever', 'pump', 'break', 'single-shot', 'unspecified')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.firearm_document": {
+      "name": "firearm_document",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "storage_key": {
+          "name": "storage_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "filename": {
+          "name": "filename",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size_bytes": {
+          "name": "size_bytes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "doc_type": {
+          "name": "doc_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'other'"
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "uploaded_at": {
+          "name": "uploaded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "firearm_document_firearm_id_idx": {
+          "name": "firearm_document_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "firearm_document_firearm_id_firearm_id_fk": {
+          "name": "firearm_document_firearm_id_firearm_id_fk",
+          "tableFrom": "firearm_document",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "firearm_document_mime_type_valid": {
+          "name": "firearm_document_mime_type_valid",
+          "value": "\"firearm_document\".\"mime_type\" in ('application/pdf', 'image/jpeg', 'image/png', 'image/webp', 'image/avif')"
+        },
+        "firearm_document_doc_type_valid": {
+          "name": "firearm_document_doc_type_valid",
+          "value": "\"firearm_document\".\"doc_type\" in ('receipt', 'warranty', 'atf-form-1', 'atf-form-4', 'manual', 'insurance', 'other')"
+        },
+        "firearm_document_size_bytes_min": {
+          "name": "firearm_document_size_bytes_min",
+          "value": "\"firearm_document\".\"size_bytes\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.firearm_photo": {
+      "name": "firearm_photo",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "storage_key": {
+          "name": "storage_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size_bytes": {
+          "name": "size_bytes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "width": {
+          "name": "width",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "height": {
+          "name": "height",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "caption": {
+          "name": "caption",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_primary": {
+          "name": "is_primary",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "uploaded_at": {
+          "name": "uploaded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "firearm_photo_firearm_id_idx": {
+          "name": "firearm_photo_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "firearm_photo_one_primary_per_firearm": {
+          "name": "firearm_photo_one_primary_per_firearm",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"firearm_photo\".\"is_primary\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "firearm_photo_firearm_id_firearm_id_fk": {
+          "name": "firearm_photo_firearm_id_firearm_id_fk",
+          "tableFrom": "firearm_photo",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "firearm_photo_sort_order_min": {
+          "name": "firearm_photo_sort_order_min",
+          "value": "\"firearm_photo\".\"sort_order\" >= 0"
+        },
+        "firearm_photo_mime_type_valid": {
+          "name": "firearm_photo_mime_type_valid",
+          "value": "\"firearm_photo\".\"mime_type\" in ('image/jpeg', 'image/png', 'image/webp', 'image/avif')"
+        },
+        "firearm_photo_size_bytes_min": {
+          "name": "firearm_photo_size_bytes_min",
+          "value": "\"firearm_photo\".\"size_bytes\" > 0"
+        },
+        "firearm_photo_width_min": {
+          "name": "firearm_photo_width_min",
+          "value": "\"firearm_photo\".\"width\" > 0"
+        },
+        "firearm_photo_height_min": {
+          "name": "firearm_photo_height_min",
+          "value": "\"firearm_photo\".\"height\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.grant": {
+      "name": "grant",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "grantee_id": {
+          "name": "grantee_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_type": {
+          "name": "parent_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_id": {
+          "name": "parent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "permission": {
+          "name": "permission",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "allow_create_on_behalf": {
+          "name": "allow_create_on_behalf",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "grant_grantee_parent_type_idx": {
+          "name": "grant_grantee_parent_type_idx",
+          "columns": [
+            {
+              "expression": "grantee_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "parent_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "grant_owner_id_user_id_fk": {
+          "name": "grant_owner_id_user_id_fk",
+          "tableFrom": "grant",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "grant_grantee_id_user_id_fk": {
+          "name": "grant_grantee_id_user_id_fk",
+          "tableFrom": "grant",
+          "tableTo": "user",
+          "columnsFrom": ["grantee_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "grant_grantee_parent_unique": {
+          "name": "grant_grantee_parent_unique",
+          "nullsNotDistinct": false,
+          "columns": ["grantee_id", "parent_type", "parent_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "grant_parent_type_valid": {
+          "name": "grant_parent_type_valid",
+          "value": "\"grant\".\"parent_type\" in ('firearm', 'magazine', 'ammo')"
+        },
+        "grant_permission_valid": {
+          "name": "grant_permission_valid",
+          "value": "\"grant\".\"permission\" in ('view', 'edit')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.idempotency": {
+      "name": "idempotency",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "result": {
+          "name": "result",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idempotency_expires_at_idx": {
+          "name": "idempotency_expires_at_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "idempotency_user_id_user_id_fk": {
+          "name": "idempotency_user_id_user_id_fk",
+          "tableFrom": "idempotency",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "idempotency_user_id_idempotency_key_pk": {
+          "name": "idempotency_user_id_idempotency_key_pk",
+          "columns": ["user_id", "idempotency_key"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.inventory_log": {
+      "name": "inventory_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "parent_type": {
+          "name": "parent_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_id": {
+          "name": "parent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "event_type": {
+          "name": "event_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "occurred_at": {
+          "name": "occurred_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "inventory_log_parent_idx": {
+          "name": "inventory_log_parent_idx",
+          "columns": [
+            {
+              "expression": "parent_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "parent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "occurred_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "inventory_log_actor_id_user_id_fk": {
+          "name": "inventory_log_actor_id_user_id_fk",
+          "tableFrom": "inventory_log",
+          "tableTo": "user",
+          "columnsFrom": ["actor_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "inventory_log_parent_type_valid": {
+          "name": "inventory_log_parent_type_valid",
+          "value": "\"inventory_log\".\"parent_type\" in ('firearm', 'magazine')"
+        },
+        "inventory_log_event_type_valid": {
+          "name": "inventory_log_event_type_valid",
+          "value": "(\"inventory_log\".\"parent_type\" = 'firearm' AND \"inventory_log\".\"event_type\" in ('inventoried')) OR (\"inventory_log\".\"parent_type\" = 'magazine' AND \"inventory_log\".\"event_type\" in ('inventoried'))"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.magazine": {
+      "name": "magazine",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "brand_model": {
+          "name": "brand_model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "caliber": {
+          "name": "caliber",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "base_capacity": {
+          "name": "base_capacity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "extension_rounds": {
+          "name": "extension_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "acquired_date": {
+          "name": "acquired_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "magazine_owner_id_idx": {
+          "name": "magazine_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "magazine_owner_id_user_id_fk": {
+          "name": "magazine_owner_id_user_id_fk",
+          "tableFrom": "magazine",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "magazine_base_capacity_min": {
+          "name": "magazine_base_capacity_min",
+          "value": "\"magazine\".\"base_capacity\" >= 1"
+        },
+        "magazine_extension_rounds_min": {
+          "name": "magazine_extension_rounds_min",
+          "value": "\"magazine\".\"extension_rounds\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.magazine_firearm": {
+      "name": "magazine_firearm",
+      "schema": "",
+      "columns": {
+        "magazine_id": {
+          "name": "magazine_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ordinal": {
+          "name": "ordinal",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "magazine_firearm_firearm_id_idx": {
+          "name": "magazine_firearm_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "magazine_firearm_magazine_id_magazine_id_fk": {
+          "name": "magazine_firearm_magazine_id_magazine_id_fk",
+          "tableFrom": "magazine_firearm",
+          "tableTo": "magazine",
+          "columnsFrom": ["magazine_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "magazine_firearm_firearm_id_firearm_id_fk": {
+          "name": "magazine_firearm_firearm_id_firearm_id_fk",
+          "tableFrom": "magazine_firearm",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "magazine_firearm_magazine_id_firearm_id_pk": {
+          "name": "magazine_firearm_magazine_id_firearm_id_pk",
+          "columns": ["magazine_id", "firearm_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.magazine_label_prefix": {
+      "name": "magazine_label_prefix",
+      "schema": "",
+      "columns": {
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "magazine_label_prefix_owner_id_user_id_fk": {
+          "name": "magazine_label_prefix_owner_id_user_id_fk",
+          "tableFrom": "magazine_label_prefix",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "magazine_label_prefix_owner_id_prefix_pk": {
+          "name": "magazine_label_prefix_owner_id_prefix_pk",
+          "columns": ["owner_id", "prefix"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.range_session": {
+      "name": "range_session",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "date": {
+          "name": "date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rounds_fired": {
+          "name": "rounds_fired",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ammo_id": {
+          "name": "ammo_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "range_session_firearm_id_idx": {
+          "name": "range_session_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "range_session_firearm_id_firearm_id_fk": {
+          "name": "range_session_firearm_id_firearm_id_fk",
+          "tableFrom": "range_session",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "range_session_rounds_fired_min": {
+          "name": "range_session_rounds_fired_min",
+          "value": "\"range_session\".\"rounds_fired\" >= 1"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.range_session_accessory": {
+      "name": "range_session_accessory",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "range_session_id": {
+          "name": "range_session_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "accessory_id": {
+          "name": "accessory_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "range_session_accessory_session_id_idx": {
+          "name": "range_session_accessory_session_id_idx",
+          "columns": [
+            {
+              "expression": "range_session_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "range_session_accessory_accessory_id_idx": {
+          "name": "range_session_accessory_accessory_id_idx",
+          "columns": [
+            {
+              "expression": "accessory_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "range_session_accessory_range_session_id_range_session_id_fk": {
+          "name": "range_session_accessory_range_session_id_range_session_id_fk",
+          "tableFrom": "range_session_accessory",
+          "tableTo": "range_session",
+          "columnsFrom": ["range_session_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "range_session_accessory_accessory_id_accessory_id_fk": {
+          "name": "range_session_accessory_accessory_id_accessory_id_fk",
+          "tableFrom": "range_session_accessory",
+          "tableTo": "accessory",
+          "columnsFrom": ["accessory_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "range_session_accessory_unique": {
+          "name": "range_session_accessory_unique",
+          "nullsNotDistinct": false,
+          "columns": ["range_session_id", "accessory_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.service_event": {
+      "name": "service_event",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "accessory_id": {
+          "name": "accessory_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rule_name": {
+          "name": "rule_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serviced_on": {
+          "name": "serviced_on",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "service_event_firearm_id_idx": {
+          "name": "service_event_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "service_event_accessory_id_idx": {
+          "name": "service_event_accessory_id_idx",
+          "columns": [
+            {
+              "expression": "accessory_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "service_event_firearm_rule_serviced_idx": {
+          "name": "service_event_firearm_rule_serviced_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "rule_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "serviced_on",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "service_event_accessory_rule_serviced_idx": {
+          "name": "service_event_accessory_rule_serviced_idx",
+          "columns": [
+            {
+              "expression": "accessory_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "rule_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "serviced_on",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "service_event_firearm_id_firearm_id_fk": {
+          "name": "service_event_firearm_id_firearm_id_fk",
+          "tableFrom": "service_event",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "service_event_accessory_id_accessory_id_fk": {
+          "name": "service_event_accessory_id_accessory_id_fk",
+          "tableFrom": "service_event",
+          "tableTo": "accessory",
+          "columnsFrom": ["accessory_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "service_event_actor_id_user_id_fk": {
+          "name": "service_event_actor_id_user_id_fk",
+          "tableFrom": "service_event",
+          "tableTo": "user",
+          "columnsFrom": ["actor_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "service_event_exactly_one_parent": {
+          "name": "service_event_exactly_one_parent",
+          "value": "num_nonnulls(\"service_event\".\"firearm_id\", \"service_event\".\"accessory_id\") = 1"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.service_rule": {
+      "name": "service_rule",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "firearm_id": {
+          "name": "firearm_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "accessory_id": {
+          "name": "accessory_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "suppressed": {
+          "name": "suppressed",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "interval_days": {
+          "name": "interval_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "interval_sessions": {
+          "name": "interval_sessions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "interval_rounds": {
+          "name": "interval_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "service_rule_firearm_id_idx": {
+          "name": "service_rule_firearm_id_idx",
+          "columns": [
+            {
+              "expression": "firearm_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "service_rule_accessory_id_idx": {
+          "name": "service_rule_accessory_id_idx",
+          "columns": [
+            {
+              "expression": "accessory_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "service_rule_firearm_id_firearm_id_fk": {
+          "name": "service_rule_firearm_id_firearm_id_fk",
+          "tableFrom": "service_rule",
+          "tableTo": "firearm",
+          "columnsFrom": ["firearm_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "service_rule_accessory_id_accessory_id_fk": {
+          "name": "service_rule_accessory_id_accessory_id_fk",
+          "tableFrom": "service_rule",
+          "tableTo": "accessory",
+          "columnsFrom": ["accessory_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "service_rule_firearm_name_unique": {
+          "name": "service_rule_firearm_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["firearm_id", "name"]
+        },
+        "service_rule_accessory_name_unique": {
+          "name": "service_rule_accessory_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["accessory_id", "name"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "service_rule_exactly_one_parent": {
+          "name": "service_rule_exactly_one_parent",
+          "value": "num_nonnulls(\"service_rule\".\"firearm_id\", \"service_rule\".\"accessory_id\") = 1"
+        },
+        "service_rule_thresholds_min": {
+          "name": "service_rule_thresholds_min",
+          "value": "(\"service_rule\".\"interval_days\" IS NULL OR \"service_rule\".\"interval_days\" >= 1) AND (\"service_rule\".\"interval_sessions\" IS NULL OR \"service_rule\".\"interval_sessions\" >= 1) AND (\"service_rule\".\"interval_rounds\" IS NULL OR \"service_rule\".\"interval_rounds\" >= 1)"
+        },
+        "service_rule_suppressed_thresholds_consistent": {
+          "name": "service_rule_suppressed_thresholds_consistent",
+          "value": "(\"service_rule\".\"suppressed\" AND num_nonnulls(\"service_rule\".\"interval_days\", \"service_rule\".\"interval_sessions\", \"service_rule\".\"interval_rounds\") = 0) OR (NOT \"service_rule\".\"suppressed\" AND num_nonnulls(\"service_rule\".\"interval_days\", \"service_rule\".\"interval_sessions\", \"service_rule\".\"interval_rounds\") >= 1)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.service_rule_default": {
+      "name": "service_rule_default",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "interval_days": {
+          "name": "interval_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "interval_sessions": {
+          "name": "interval_sessions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "interval_rounds": {
+          "name": "interval_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "service_rule_default_owner_id_idx": {
+          "name": "service_rule_default_owner_id_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "service_rule_default_owner_id_user_id_fk": {
+          "name": "service_rule_default_owner_id_user_id_fk",
+          "tableFrom": "service_rule_default",
+          "tableTo": "user",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "service_rule_default_owner_scope_category_name_unique": {
+          "name": "service_rule_default_owner_scope_category_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["owner_id", "scope", "category", "name"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "service_rule_default_scope_valid": {
+          "name": "service_rule_default_scope_valid",
+          "value": "\"service_rule_default\".\"scope\" in ('firearm', 'accessory')"
+        },
+        "service_rule_default_has_threshold": {
+          "name": "service_rule_default_has_threshold",
+          "value": "num_nonnulls(\"service_rule_default\".\"interval_days\", \"service_rule_default\".\"interval_sessions\", \"service_rule_default\".\"interval_rounds\") >= 1"
+        },
+        "service_rule_default_thresholds_min": {
+          "name": "service_rule_default_thresholds_min",
+          "value": "(\"service_rule_default\".\"interval_days\" IS NULL OR \"service_rule_default\".\"interval_days\" >= 1) AND (\"service_rule_default\".\"interval_sessions\" IS NULL OR \"service_rule_default\".\"interval_sessions\" >= 1) AND (\"service_rule_default\".\"interval_rounds\" IS NULL OR \"service_rule_default\".\"interval_rounds\" >= 1)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.operator_audit": {
+      "name": "operator_audit",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "actor": {
+          "name": "actor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "outcome": {
+          "name": "outcome",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "at": {
+          "name": "at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "operator_audit_at_idx": {
+          "name": "operator_audit_at_idx",
+          "columns": [
+            {
+              "expression": "at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "operator_audit_action_valid": {
+          "name": "operator_audit_action_valid",
+          "value": "\"operator_audit\".\"action\" in ('export', 'restore')"
+        }
+      },
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
diff --git a/src/db/migrations/meta/_journal.json b/src/db/migrations/meta/_journal.json
index a1ae28de..d5061390 100644
--- a/src/db/migrations/meta/_journal.json
+++ b/src/db/migrations/meta/_journal.json
@@ -134,6 +134,27 @@
       "when": 1783890417560,
       "tag": "0018_spotty_blonde_phantom",
       "breakpoints": true
+    },
+    {
+      "idx": 19,
+      "version": "7",
+      "when": 1785731323900,
+      "tag": "0019_perfect_nebula",
+      "breakpoints": true
+    },
+    {
+      "idx": 20,
+      "version": "7",
+      "when": 1785737503751,
+      "tag": "0020_naive_scarlet_spider",
+      "breakpoints": true
+    },
+    {
+      "idx": 21,
+      "version": "7",
+      "when": 1785849296341,
+      "tag": "0021_shocking_shooting_star",
+      "breakpoints": true
     }
   ]
 }
diff --git a/src/demo/__tests__/inventory.test.ts b/src/demo/__tests__/inventory.test.ts
index 09bc642b..e414a77a 100644
--- a/src/demo/__tests__/inventory.test.ts
+++ b/src/demo/__tests__/inventory.test.ts
@@ -1,13 +1,23 @@
-import { describe, expect, test } from "bun:test";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  setSystemTime,
+  test,
+} from "bun:test";
+import { differenceInCalendarDays, parseISO } from "date-fns";
 import {
   MAGPUL_LABEL_ALLOWED_RE,
   MAX_LABEL_LENGTH,
 } from "@/src/domain/magazines/constants";
+import { ISO_DATE, todayIso } from "@/src/lib/dates";
 import {
   bulkMagazines,
   DEMO_ACCESSORIES,
   DEMO_AMMO,
   DEMO_FIREARMS,
+  isoDateDaysAgo,
 } from "../inventory";
 
 /**
@@ -87,3 +97,49 @@ describe("demo dataset integrity", () => {
     expect(new Set(names).size).toBe(names.length);
   });
 });
+
+/**
+ * F8: `isoDateDaysAgo` had no unit test despite being pure, TZ-sensitive,
+ * local-frame date arithmetic (KTD5) now used by e2e specs. No fixed "now"
+ * is asserted here — these check relative, local-frame properties that hold
+ * regardless of the runner's actual clock or timezone.
+ */
+describe("isoDateDaysAgo", () => {
+  // `isoDateDaysAgo` and `todayIso` each read the system clock independently
+  // (`new Date()` inside their own bodies, no shared reference-date
+  // parameter), so two calls straddling local midnight would disagree on the
+  // day even though both implementations are correct. Freezing the clock for
+  // this describe block (local noon, clear of any DST transition) removes
+  // that race without widening either function's signature just for a test.
+  beforeEach(() => {
+    setSystemTime(new Date(2026, 5, 15, 12));
+  });
+
+  afterEach(() => {
+    setSystemTime();
+  });
+
+  test("zero days ago is today's local calendar date", () => {
+    expect(isoDateDaysAgo(0)).toBe(todayIso());
+  });
+
+  test("returns a well-formed ISO calendar date for a typical offset", () => {
+    expect(ISO_DATE.test(isoDateDaysAgo(45))).toBe(true);
+  });
+
+  test("is local-frame calendar-day arithmetic, exact regardless of runner timezone", () => {
+    const ninetyDaysAgo = isoDateDaysAgo(90);
+    const today = isoDateDaysAgo(0);
+    expect(
+      differenceInCalendarDays(parseISO(today), parseISO(ninetyDaysAgo)),
+    ).toBe(90);
+  });
+
+  test("crossing a year boundary (the SBR's 900-day acquiredDaysAgo) still resolves to a real, correctly-offset calendar date", () => {
+    const longAgo = isoDateDaysAgo(900);
+    expect(ISO_DATE.test(longAgo)).toBe(true);
+    expect(
+      differenceInCalendarDays(parseISO(todayIso()), parseISO(longAgo)),
+    ).toBe(900);
+  });
+});
diff --git a/src/demo/inventory.ts b/src/demo/inventory.ts
index 7e66fdab..888fd203 100644
--- a/src/demo/inventory.ts
+++ b/src/demo/inventory.ts
@@ -15,6 +15,7 @@
  * `e2e/fixtures/`, which would drag Playwright into the plain Bun seed script.
  */
 
+import { format } from "date-fns";
 import type {
   FirearmAction,
   FirearmType,
@@ -27,6 +28,15 @@ export interface DemoFirearmSeed {
   type: FirearmType;
   action: FirearmAction;
   isNfa?: boolean;
+  /**
+   * Days before "now" this firearm was acquired (service-intervals plan,
+   * R22/U6). A day COUNT, not a stored date — `isoDateDaysAgo` resolves it
+   * relative to whenever the seed actually runs, so the demo keeps showing a
+   * mix of due and not-due service rules indefinitely rather than going
+   * stale the day after it was written. Omitted means no acquired date (the
+   * origin date falls back to record creation, KTD9).
+   */
+  acquiredDaysAgo?: number;
 }
 
 export interface DemoMagazineSeed {
@@ -57,6 +67,17 @@ export interface DemoAccessorySeed {
   isNfa?: boolean;
   /** Mount target, by firearm `name` — resolved to an id at seed time. */
   mount?: DemoFirearmName;
+  /**
+   * Days before "now" this accessory was acquired — added during
+   * implementation, mirroring `DemoFirearmSeed.acquiredDaysAgo` exactly (see
+   * the service-intervals plan's "Scope added during implementation" note).
+   * A day COUNT, not a stored date; resolved via `isoDateDaysAgo` at seed
+   * time. Omitted means no acquired date (the origin date falls back to
+   * record creation, KTD9) — at least one seed sets this so the demo proves
+   * the cold-start difference: a backdated accessory reads due on day one,
+   * one without an acquired date does not.
+   */
+  acquiredDaysAgo?: number;
 }
 
 export const DEMO_FIREARMS = [
@@ -66,6 +87,7 @@ export const DEMO_FIREARMS = [
     type: "rifle",
     action: "semi-auto",
     isNfa: true,
+    acquiredDaysAgo: 900,
   },
   {
     name: "SIG P320 XCarry",
@@ -73,6 +95,7 @@ export const DEMO_FIREARMS = [
     type: "pistol",
     action: "semi-auto",
     isNfa: false,
+    acquiredDaysAgo: 400,
   },
   {
     name: "Glock 19 Gen5",
@@ -80,9 +103,25 @@ export const DEMO_FIREARMS = [
     type: "pistol",
     action: "semi-auto",
     isNfa: false,
+    acquiredDaysAgo: 150,
   },
 ] as const satisfies readonly DemoFirearmSeed[];
 
+/**
+ * ISO calendar date (`YYYY-MM-DD`) `daysAgo` days before "now", built from
+ * local Y/M/D components rather than a UTC offset (service-intervals plan
+ * KTD5) — matches how the derivation core compares calendar days, so a seed
+ * fixture built here lands on the same local day a viewer's due computation
+ * measures against. `date-fns`'s `format` reads the same local Y/M/D getters
+ * `setDate`'s local calendar-day rollover already leaves in place, so this is
+ * behavior-equivalent to (and replaces) a manual padStart build.
+ */
+export function isoDateDaysAgo(daysAgo: number): string {
+  const date = new Date();
+  date.setDate(date.getDate() - daysAgo);
+  return format(date, "yyyy-MM-dd");
+}
+
 /**
  * The firearm names this module declares. `DemoAccessorySeed.mount` is typed to
  * this, so renaming a firearm without updating its accessories is a typecheck
@@ -90,6 +129,90 @@ export const DEMO_FIREARMS = [
  */
 export type DemoFirearmName = (typeof DEMO_FIREARMS)[number]["name"];
 
+/**
+ * Category default rule seeds (service-intervals plan, U10) — arms the whole
+ * collection from "settings" before any item is visited (F1), the same way an
+ * owner would. Days-only thresholds keep the demo's due state legible without
+ * also having to seed range-session rows to drive the sessions/rounds axes.
+ */
+export interface DemoServiceDefaultSeed {
+  scope: "firearm" | "accessory";
+  category: string;
+  name: string;
+  intervalDays?: number | null;
+  intervalSessions?: number | null;
+  intervalRounds?: number | null;
+}
+
+export const DEMO_SERVICE_DEFAULTS: readonly DemoServiceDefaultSeed[] = [
+  { scope: "firearm", category: "rifle", name: "Cleaning", intervalDays: 180 },
+  { scope: "firearm", category: "rifle", name: "Barrel", intervalDays: 730 },
+  {
+    scope: "firearm",
+    category: "pistol",
+    name: "Cleaning",
+    intervalDays: 120,
+  },
+  // Matches DEMO_ACCESSORIES' "Optic" category (the Aimpoint CompM5, seeded
+  // with acquiredDaysAgo: 900) — without a matching accessory default, that
+  // accessory resolves NO effective rule at all and can never read due,
+  // which would break the cold-start example the seed narrative describes
+  // (see DemoAccessorySeed.acquiredDaysAgo's doc). 365 days comfortably
+  // clears the 900-day-old origin date, so the accessory reads due on day
+  // one, same as the story requires.
+  {
+    scope: "accessory",
+    category: "Optic",
+    name: "Battery Check",
+    intervalDays: 365,
+  },
+];
+
+/**
+ * Per-item overrides and suppressions (F3, AE1, AE5) — a couple, not a whole
+ * second default set, so the demo shows divergence without obscuring the
+ * live-inheritance story the defaults above already tell.
+ */
+export interface DemoServiceOverrideSeed {
+  firearmName: DemoFirearmName;
+  name: string;
+  suppressed?: boolean;
+  intervalDays?: number | null;
+}
+
+export const DEMO_SERVICE_OVERRIDES: readonly DemoServiceOverrideSeed[] = [
+  // The SBR sees harder use than an average rifle, so its barrel interval is
+  // tightened well below the rifle default — the override stands even after
+  // the default later changes (F3/AE1).
+  { firearmName: 'BCM 11.5" SBR', name: "Barrel", intervalDays: 365 },
+  // A nightstand gun the owner doesn't want nagged about — a suppressed rule
+  // never surfaces as due, however overdue it would otherwise read (AE5).
+  { firearmName: "Glock 19 Gen5", name: "Cleaning", suppressed: true },
+];
+
+/**
+ * Service history (R14/R17) — `daysAgo` is relative to seed time (like
+ * `DemoFirearmSeed.acquiredDaysAgo`), resolved through `isoDateDaysAgo`.
+ * Logging the SBR's Cleaning rule recently means its panel shows one due rule
+ * (Barrel, overridden above) beside one not-due rule (Cleaning) at the same
+ * time — the mix a demo where everything is due would never prove.
+ */
+export interface DemoServiceHistorySeed {
+  firearmName: DemoFirearmName;
+  ruleName: string;
+  daysAgo: number;
+  notes?: string;
+}
+
+export const DEMO_SERVICE_HISTORY: readonly DemoServiceHistorySeed[] = [
+  {
+    firearmName: 'BCM 11.5" SBR',
+    ruleName: "Cleaning",
+    daysAgo: 30,
+    notes: "Wiped down and lubed after the range.",
+  },
+];
+
 /** The curated three used by the README captures. */
 export const DEMO_MAGAZINES: readonly DemoMagazineSeed[] = [
   {
@@ -128,6 +251,10 @@ export const DEMO_ACCESSORIES: readonly DemoAccessorySeed[] = [
     serialNumber: "AP-CM5-88213",
     costCents: 85_000,
     mount: 'BCM 11.5" SBR',
+    // Bought alongside the SBR it's mounted on (R22-parity; demonstrates the
+    // cold-start fix — see DemoAccessorySeed.acquiredDaysAgo's doc). The
+    // ACOG below carries no acquired date, so the demo shows both states.
+    acquiredDaysAgo: 900,
   },
   {
     category: "Suppressor",
diff --git a/src/domain/accessories/__tests__/service.test.ts b/src/domain/accessories/__tests__/service.test.ts
index 3c7d2e0f..fde3a1ec 100644
--- a/src/domain/accessories/__tests__/service.test.ts
+++ b/src/domain/accessories/__tests__/service.test.ts
@@ -228,3 +228,98 @@ describe("accessory service (accessory plan U4)", () => {
     ).rejects.toBeInstanceOf(NotAuthorizedError);
   });
 });
+
+// Acquired date round-trip — added during implementation, mirroring
+// `src/domain/firearms/__tests__/service.test.ts`'s "acquired date (U6)"
+// suite exactly (service-intervals plan R22/KTD9-parity). The origin-date
+// derivation itself is covered in
+// `src/domain/service-intervals/__tests__/due-service.test.ts`; this suite
+// covers only create/update/clear and the validation gate.
+describe("accessory service — acquired date", () => {
+  let userA = "";
+
+  beforeAll(async () => {
+    userA = await createUser("AccAcquiredDate");
+  });
+  afterAll(async () => {
+    await deleteUsers(userA);
+  });
+
+  test("creating without an acquired date stores null", async () => {
+    const acc = await createAccessory(userA, { category: "optic" });
+    expect(acc.acquiredDate).toBeNull();
+  });
+
+  test("creating with an acquired date persists it", async () => {
+    const acc = await createAccessory(userA, {
+      category: "optic",
+      acquiredDate: "2026-06-14",
+    });
+    expect(acc.acquiredDate).toBe("2026-06-14");
+  });
+
+  test("an update can set an acquired date that was previously unset", async () => {
+    const acc = await createAccessory(userA, { category: "optic" });
+    expect(acc.acquiredDate).toBeNull();
+    const updated = await updateAccessory(userA, acc.id, {
+      category: "optic",
+      acquiredDate: "2026-03-01",
+    });
+    expect(updated.acquiredDate).toBe("2026-03-01");
+  });
+
+  test("an update can clear a previously-set acquired date back to null", async () => {
+    const acc = await createAccessory(userA, {
+      category: "optic",
+      acquiredDate: "2026-01-01",
+    });
+    expect(acc.acquiredDate).toBe("2026-01-01");
+    const cleared = await updateAccessory(userA, acc.id, {
+      category: "optic",
+      acquiredDate: null,
+    });
+    expect(cleared.acquiredDate).toBeNull();
+  });
+
+  test("a malformed acquired date is rejected and writes no row (create)", async () => {
+    const before = await listAccessories(userA);
+    await expect(
+      createAccessory(userA, {
+        category: "optic",
+        acquiredDate: "not-a-date",
+      }),
+    ).rejects.toBeInstanceOf(ValidationError);
+    const after = await listAccessories(userA);
+    expect(after.length).toBe(before.length);
+  });
+
+  test("a malformed acquired date is rejected and leaves the existing row unchanged (update)", async () => {
+    const acc = await createAccessory(userA, {
+      category: "optic",
+      acquiredDate: "2026-01-01",
+    });
+    await expect(
+      updateAccessory(userA, acc.id, {
+        category: "optic",
+        acquiredDate: "2026-13-40",
+      }),
+    ).rejects.toBeInstanceOf(ValidationError);
+    const { accessory: row } = await getAccessory(userA, acc.id);
+    expect(row.acquiredDate).toBe("2026-01-01");
+  });
+
+  test("acquiredDate is independent of mount/unmount — unmounting never clears it (unlike installedDate)", async () => {
+    const fa = await makeFirearm(userA, { name: "AcquiredIndependentFA" });
+    const acc = await createAccessory(userA, {
+      category: "optic",
+      acquiredDate: "2020-05-01",
+      firearmId: fa.id,
+      installedDate: "2026-01-01",
+    });
+    expect(acc.acquiredDate).toBe("2020-05-01");
+
+    const unmounted = await mountAccessory(userA, acc.id, null);
+    expect(unmounted.installedDate).toBeNull();
+    expect(unmounted.acquiredDate).toBe("2020-05-01");
+  });
+});
diff --git a/src/domain/accessories/__tests__/validate.test.ts b/src/domain/accessories/__tests__/validate.test.ts
index 9bc70d96..fe31dc34 100644
--- a/src/domain/accessories/__tests__/validate.test.ts
+++ b/src/domain/accessories/__tests__/validate.test.ts
@@ -85,6 +85,91 @@ describe("validateAccessory", () => {
   });
 });
 
+// Acquired date — added during implementation, mirroring `validateFirearm`'s
+// acquiredDate coverage exactly (service-intervals plan R22/KTD9-parity, see
+// the plan's "Scope added during implementation" note).
+describe("validateAccessory — acquiredDate", () => {
+  test("omitted acquiredDate is valid (unset)", () => {
+    expect(validateAccessory(base)).toEqual([]);
+  });
+
+  test("null acquiredDate is valid (explicit unset/clear)", () => {
+    expect(validateAccessory({ ...base, acquiredDate: null })).toEqual([]);
+  });
+
+  test("a real ISO calendar date is valid", () => {
+    expect(validateAccessory({ ...base, acquiredDate: "2026-06-14" })).toEqual(
+      [],
+    );
+  });
+
+  test("a malformed date string returns invalidAcquiredDate", () => {
+    expect(validateAccessory({ ...base, acquiredDate: "not-a-date" })).toEqual([
+      "invalidAcquiredDate",
+    ]);
+  });
+
+  test("an empty string is treated as malformed, not unset (the caller normalizes '' to null)", () => {
+    expect(validateAccessory({ ...base, acquiredDate: "" })).toEqual([
+      "invalidAcquiredDate",
+    ]);
+  });
+
+  test("an impossible calendar day (day overflow) returns invalidAcquiredDate", () => {
+    expect(validateAccessory({ ...base, acquiredDate: "2026-02-31" })).toEqual([
+      "invalidAcquiredDate",
+    ]);
+  });
+
+  test("year zero returns invalidAcquiredDate (Postgres's date type has no year 0)", () => {
+    expect(validateAccessory({ ...base, acquiredDate: "0000-01-01" })).toEqual([
+      "invalidAcquiredDate",
+    ]);
+  });
+
+  test("combines with other failures rather than short-circuiting", () => {
+    expect(
+      validateAccessory({
+        category: "",
+        acquiredDate: "nope",
+      }),
+    ).toEqual(["emptyCategory", "invalidAcquiredDate"]);
+  });
+});
+
+// A future acquiredDate must be rejected with the same one-calendar-day
+// tolerance `validateFirearm` uses (shared `FUTURE_DATE_TOLERANCE_DAYS`) — a
+// future value would silently freeze this accessory's due state (KTD9).
+describe("validateAccessory — acquiredDateInFuture", () => {
+  test("an acquired date on the server's own day is accepted", () => {
+    const asOf = new Date(2026, 5, 15);
+    expect(
+      validateAccessory({ ...base, acquiredDate: "2026-06-15" }, asOf),
+    ).toEqual([]);
+  });
+
+  test("an acquired date one day ahead of the server's day is accepted (timezone-ahead submitter case)", () => {
+    const asOf = new Date(2026, 5, 15);
+    expect(
+      validateAccessory({ ...base, acquiredDate: "2026-06-16" }, asOf),
+    ).toEqual([]);
+  });
+
+  test("an acquired date two days ahead of the server's day is rejected", () => {
+    const asOf = new Date(2026, 5, 15);
+    expect(
+      validateAccessory({ ...base, acquiredDate: "2026-06-17" }, asOf),
+    ).toEqual(["acquiredDateInFuture"]);
+  });
+
+  test("a far-future acquired date is rejected", () => {
+    const asOf = new Date(2026, 5, 15);
+    expect(
+      validateAccessory({ ...base, acquiredDate: "2099-01-01" }, asOf),
+    ).toEqual(["acquiredDateInFuture"]);
+  });
+});
+
 describe("ACCESSORY_CATEGORY_SUGGESTIONS", () => {
   test("contains suppressor and optic", () => {
     expect(ACCESSORY_CATEGORY_SUGGESTIONS).toContain("suppressor");
diff --git a/src/domain/accessories/service.ts b/src/domain/accessories/service.ts
index 6a5be79a..9ed70c2e 100644
--- a/src/domain/accessories/service.ts
+++ b/src/domain/accessories/service.ts
@@ -70,6 +70,12 @@ function persistableFields(
     model: input.model ?? "",
     serialNumber: input.serialNumber ?? "",
     installedDate: mountedFirearmId ? (input.installedDate ?? null) : null,
+    // Added during implementation, mirroring `firearm.acquiredDate` (R22):
+    // null means unset, not "unknown but zero" — the service-interval origin
+    // date (KTD9) depends on that distinction. Unlike `installedDate`, this
+    // is NOT force-nulled on unmount — it records when the OWNER acquired
+    // the accessory, not when it was last mounted.
+    acquiredDate: input.acquiredDate ?? null,
     costCents: input.costCents ?? null,
     notes: input.notes ?? "",
     isNfa: input.isNfa ?? false,
diff --git a/src/domain/accessories/validate.ts b/src/domain/accessories/validate.ts
index 33f43b29..c0da4bbb 100644
--- a/src/domain/accessories/validate.ts
+++ b/src/domain/accessories/validate.ts
@@ -6,17 +6,37 @@
  * (mirrors ammo's `caliber`); `brand`/`model`/`serialNumber`/`notes` are
  * optional free text handled entirely by the service layer's empty-not-null
  * defaulting (R18), so they carry no validation code here. `costCents` is
- * nullable (unset cost is unknown, not zero — KTD-7-style) and, when present,
+ * nullable (unset cost is unknown, not zero) and, when present,
  * must be a non-negative integer within the int4 bound (#53). `installedDate`
  * is nullable and, when present, must be a real ISO calendar date (mirrors
  * range-sessions' `date` check).
+ *
+ * `acquiredDate` is nullable and, when present, must be a real ISO calendar
+ * date, and not more than `FUTURE_DATE_TOLERANCE_DAYS` after `asOf` — added
+ * during implementation, mirroring `firearm.acquiredDate`'s validator
+ * (service-intervals plan R22/KTD9) exactly, including the same one-
+ * calendar-day future tolerance and the same reason for it: `asOf` is the
+ * SERVER's clock, and a submitter whose local calendar day genuinely runs
+ * ahead of it must not be rejected for submitting their own today. It also
+ * feeds the service-interval origin date (`due-service.ts`), so a future
+ * value would silently freeze that accessory's due state until the clock
+ * caught up — rejected here rather than left to the Postgres `date` cast.
  */
 
+import { differenceInCalendarDays, parseISO } from "date-fns";
+import {
+  FUTURE_DATE_TOLERANCE_DAYS,
+  ISO_DATE,
+  isRealCalendarDate,
+} from "@/src/lib/dates";
+
 export type AccessoryValidationCode =
   | "emptyCategory"
   | "negativeCostCents"
   | "invalidCostCents"
-  | "invalidInstalledDate";
+  | "invalidInstalledDate"
+  | "invalidAcquiredDate"
+  | "acquiredDateInFuture";
 
 /**
  * Upper bound for `costCents`: Postgres int4 max (#53). Validated here so an
@@ -25,33 +45,28 @@ export type AccessoryValidationCode =
  */
 export const MAX_COST_CENTS = 2_147_483_647;
 
-const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
-
-/**
- * True only for a real calendar date. `Date.parse` NORMALIZES day overflow
- * (e.g. `2026-02-31` → Mar 3) instead of returning NaN, so a round-trip
- * compare against the UTC-normalized ISO date is what rejects impossible
- * days — the Postgres `date` cast would otherwise reject them downstream.
- */
-function isRealCalendarDate(date: string): boolean {
-  const parsed = Date.parse(date);
-  if (Number.isNaN(parsed)) return false;
-  return new Date(parsed).toISOString().slice(0, 10) === date;
-}
-
 export interface AccessoryFields {
   category: string;
   brand?: string;
   model?: string;
   serialNumber?: string;
   installedDate?: string | null;
+  /** ISO calendar date, or null/undefined when unset. See file header. */
+  acquiredDate?: string | null;
   costCents?: number | null;
   notes?: string;
   isNfa?: boolean;
 }
 
+/**
+ * `asOf` is the reference "now" the not-in-the-future `acquiredDate` check
+ * compares against — an explicit parameter (default `new Date()`, the
+ * server's clock) so this stays a pure, deterministic function for tests,
+ * mirroring `validateFirearm`'s shape exactly.
+ */
 export function validateAccessory(
   input: AccessoryFields,
+  asOf: Date = new Date(),
 ): AccessoryValidationCode[] {
   const codes: AccessoryValidationCode[] = [];
 
@@ -74,5 +89,17 @@ export function validateAccessory(
     }
   }
 
+  if (input.acquiredDate !== null && input.acquiredDate !== undefined) {
+    const date = input.acquiredDate.trim();
+    if (date === "" || !ISO_DATE.test(date) || !isRealCalendarDate(date)) {
+      codes.push("invalidAcquiredDate");
+    } else if (
+      differenceInCalendarDays(parseISO(date), asOf) >
+      FUTURE_DATE_TOLERANCE_DAYS
+    ) {
+      codes.push("acquiredDateInFuture");
+    }
+  }
+
   return codes;
 }
diff --git a/src/domain/firearms/__tests__/service.test.ts b/src/domain/firearms/__tests__/service.test.ts
index 931bfc09..6a452d99 100644
--- a/src/domain/firearms/__tests__/service.test.ts
+++ b/src/domain/firearms/__tests__/service.test.ts
@@ -700,3 +700,106 @@ describe("firearms service — action-log wiring (U6)", () => {
     spy.mockRestore();
   });
 });
+
+// Acquired date round-trip (service-intervals plan U6, R22/R10, KTD9). It
+// also feeds the service-interval origin date — that derivation itself is
+// covered where it's implemented, in
+// src/domain/service-intervals/__tests__/due-service.test.ts ("cold start
+// counts from the acquired date" / "a firearm with no acquired date measures
+// from its creation date"); this suite covers only create/update/clear and
+// the validation gate.
+describe("firearms service — acquired date (U6)", () => {
+  let userA = "";
+
+  beforeAll(async () => {
+    userA = await createUser("AcquiredDate");
+  });
+  afterAll(async () => {
+    await deleteUsers(userA);
+  });
+
+  test("creating without an acquired date stores null", async () => {
+    const fa = await createFirearm(userA, {
+      name: "No Date",
+      caliber: "9mm",
+      ...CLASS,
+    });
+    expect(fa.acquiredDate).toBeNull();
+  });
+
+  test("creating with an acquired date persists it", async () => {
+    const fa = await createFirearm(userA, {
+      name: "Dated",
+      caliber: "9mm",
+      ...CLASS,
+      acquiredDate: "2026-06-14",
+    });
+    expect(fa.acquiredDate).toBe("2026-06-14");
+  });
+
+  test("an update can set an acquired date that was previously unset", async () => {
+    const fa = await createFirearm(userA, {
+      name: "SetLater",
+      caliber: "9mm",
+      ...CLASS,
+    });
+    expect(fa.acquiredDate).toBeNull();
+    const updated = await updateFirearm(userA, fa.id, {
+      name: "SetLater",
+      caliber: "9mm",
+      ...CLASS,
+      acquiredDate: "2026-03-01",
+    });
+    expect(updated.acquiredDate).toBe("2026-03-01");
+  });
+
+  test("an update can clear a previously-set acquired date back to null", async () => {
+    const fa = await createFirearm(userA, {
+      name: "Clearable",
+      caliber: "9mm",
+      ...CLASS,
+      acquiredDate: "2026-01-01",
+    });
+    expect(fa.acquiredDate).toBe("2026-01-01");
+    const cleared = await updateFirearm(userA, fa.id, {
+      name: "Clearable",
+      caliber: "9mm",
+      ...CLASS,
+      acquiredDate: null,
+    });
+    expect(cleared.acquiredDate).toBeNull();
+  });
+
+  test("a malformed acquired date is rejected and writes no row (create)", async () => {
+    const before = await listFirearms(userA);
+    await expect(
+      createFirearm(userA, {
+        name: "Bad Date",
+        caliber: "9mm",
+        ...CLASS,
+        acquiredDate: "not-a-date",
+      }),
+    ).rejects.toBeInstanceOf(ValidationError);
+    const after = await listFirearms(userA);
+    expect(after.length).toBe(before.length);
+  });
+
+  test("a malformed acquired date is rejected and leaves the existing row unchanged (update)", async () => {
+    const fa = await createFirearm(userA, {
+      name: "GuardedUpdate",
+      caliber: "9mm",
+      ...CLASS,
+      acquiredDate: "2026-01-01",
+    });
+    await expect(
+      updateFirearm(userA, fa.id, {
+        name: "GuardedUpdate",
+        caliber: "9mm",
+        ...CLASS,
+        acquiredDate: "2026-13-40",
+      }),
+    ).rejects.toBeInstanceOf(ValidationError);
+    const [row] = await db.select().from(firearm).where(eq(firearm.id, fa.id));
+    expect(row.acquiredDate).toBe("2026-01-01");
+  });
+});
diff --git a/src/domain/firearms/__tests__/validate.test.ts b/src/domain/firearms/__tests__/validate.test.ts
index fed8edaf..e54f2fa5 100644
--- a/src/domain/firearms/__tests__/validate.test.ts
+++ b/src/domain/firearms/__tests__/validate.test.ts
@@ -100,3 +100,193 @@ describe("validateFirearm — taxonomy (U3)", () => {
     }
   });
 });
+
+// Acquired date (U6, service-intervals plan R22/R10, KTD9).
+describe("validateFirearm — acquiredDate (U6)", () => {
+  test("omitted acquiredDate is valid (unset)", () => {
+    expect(
+      validateFirearm({ name: "Glock 19", caliber: "9mm", ...CLASS }),
+    ).toEqual([]);
+  });
+
+  test("null acquiredDate is valid (explicit unset/clear)", () => {
+    expect(
+      validateFirearm({
+        name: "Glock 19",
+        caliber: "9mm",
+        ...CLASS,
+        acquiredDate: null,
+      }),
+    ).toEqual([]);
+  });
+
+  test("a real ISO calendar date is valid", () => {
+    const asOf = new Date(2026, 5, 15);
+    expect(
+      validateFirearm(
+        {
+          name: "Glock 19",
+          caliber: "9mm",
+          ...CLASS,
+          acquiredDate: "2026-06-14",
+        },
+        asOf,
+      ),
+    ).toEqual([]);
+  });
+
+  test("a malformed date string returns invalidAcquiredDate", () => {
+    expect(
+      validateFirearm({
+        name: "Glock 19",
+        caliber: "9mm",
+        ...CLASS,
+        acquiredDate: "not-a-date",
+      }),
+    ).toEqual(["invalidAcquiredDate"]);
+  });
+
+  test("an empty string is treated as malformed, not unset (the caller normalizes '' to null)", () => {
+    expect(
+      validateFirearm({
+        name: "Glock 19",
+        caliber: "9mm",
+        ...CLASS,
+        acquiredDate: "",
+      }),
+    ).toEqual(["invalidAcquiredDate"]);
+  });
+
+  test("an impossible calendar day (day overflow) returns invalidAcquiredDate", () => {
+    expect(
+      validateFirearm({
+        name: "Glock 19",
+        caliber: "9mm",
+        ...CLASS,
+        acquiredDate: "2026-02-31",
+      }),
+    ).toEqual(["invalidAcquiredDate"]);
+  });
+
+  test("year zero returns invalidAcquiredDate (Postgres's date type has no year 0)", () => {
+    expect(
+      validateFirearm({
+        name: "Glock 19",
+        caliber: "9mm",
+        ...CLASS,
+        acquiredDate: "0000-01-01",
+      }),
+    ).toEqual(["invalidAcquiredDate"]);
+  });
+
+  test("combines with other failures rather than short-circuiting (R20)", () => {
+    expect(
+      validateFirearm({
+        name: "",
+        caliber: "9mm",
+        ...CLASS,
+        acquiredDate: "nope",
+      }),
+    ).toEqual(["emptyName", "invalidAcquiredDate"]);
+  });
+
+  test("messageForCode returns a non-default string for invalidAcquiredDate", () => {
+    expect(messageForCode("invalidAcquiredDate")).not.toBe("Invalid value");
+  });
+});
+
+// F3: a future acquiredDate must be rejected, mirroring `validateServicedOn`
+// — a future acquired date makes `derive.ts`'s `measureFrom` future too, so
+// elapsed days clamp to 0 and every rule silently never trips until the
+// clock catches up. `asOf` is an explicit parameter (default `new Date()`)
+// so this stays deterministic for tests.
+describe("validateFirearm — acquiredDateInFuture (F3)", () => {
+  test("an acquired date on the server's own day is accepted", () => {
+    const asOf = new Date(2026, 5, 15);
+    expect(
+      validateFirearm(
+        {
+          name: "Glock 19",
+          caliber: "9mm",
+          ...CLASS,
+          acquiredDate: "2026-06-15",
+        },
+        asOf,
+      ),
+    ).toEqual([]);
+  });
+
+  test("an acquired date one day ahead of the server's day is accepted (the timezone-ahead submitter case, same tolerance as F1)", () => {
+    const asOf = new Date(2026, 5, 15);
+    expect(
+      validateFirearm(
+        {
+          name: "Glock 19",
+          caliber: "9mm",
+          ...CLASS,
+          acquiredDate: "2026-06-16",
+        },
+        asOf,
+      ),
+    ).toEqual([]);
+  });
+
+  test("an acquired date two days ahead of the server's day is rejected", () => {
+    const asOf = new Date(2026, 5, 15);
+    expect(
+      validateFirearm(
+        {
+          name: "Glock 19",
+          caliber: "9mm",
+          ...CLASS,
+          acquiredDate: "2026-06-17",
+        },
+        asOf,
+      ),
+    ).toEqual(["acquiredDateInFuture"]);
+  });
+
+  test("a far-future acquired date is rejected", () => {
+    const asOf = new Date(2026, 5, 15);
+    expect(
+      validateFirearm(
+        {
+          name: "Glock 19",
+          caliber: "9mm",
+          ...CLASS,
+          acquiredDate: "2099-01-01",
+        },
+        asOf,
+      ),
+    ).toEqual(["acquiredDateInFuture"]);
+  });
+
+  test("combines with other failures rather than short-circuiting (R20)", () => {
+    const asOf = new Date(2026, 5, 15);
+    expect(
+      validateFirearm(
+        { name: "", caliber: "9mm", ...CLASS, acquiredDate: "2099-01-01" },
+        asOf,
+      ),
+    ).toEqual(["emptyName", "acquiredDateInFuture"]);
+  });
+
+  test("a malformed date takes priority over the future check (only invalidAcquiredDate is returned)", () => {
+    const asOf = new Date(2026, 5, 15);
+    expect(
+      validateFirearm(
+        {
+          name: "Glock 19",
+          caliber: "9mm",
+          ...CLASS,
+          acquiredDate: "2026-02-31",
+        },
+        asOf,
+      ),
+    ).toEqual(["invalidAcquiredDate"]);
+  });
+
+  test("messageForCode returns a non-default string for acquiredDateInFuture", () => {
+    expect(messageForCode("acquiredDateInFuture")).not.toBe("Invalid value");
+  });
+});
diff --git a/src/domain/firearms/service.ts b/src/domain/firearms/service.ts
index a3674d14..38875501 100644
--- a/src/domain/firearms/service.ts
+++ b/src/domain/firearms/service.ts
@@ -40,6 +40,11 @@ export interface FirearmCreateInput extends FirearmInput {
   ownerId?: string;
 }
 
+// `acquiredDate` (service-intervals plan R22) is already on `FirearmInput`,
+// validated by `validateFirearm`, and carried through both create and update
+// below — null means unset, not "unknown but zero" (KTD9's origin-date
+// fallback to `createdAt` depends on that distinction).
+
 export type FirearmUpdateInput = Omit<FirearmCreateInput, "ownerId">;
 
 function persistableFields(input: FirearmCreateInput | FirearmUpdateInput) {
@@ -60,6 +65,7 @@ function persistableFields(input: FirearmCreateInput | FirearmUpdateInput) {
     serialNumber: input.serialNumber ?? "",
     notes: input.notes ?? "",
     isNfa: input.isNfa ?? false,
+    acquiredDate: input.acquiredDate ?? null,
   };
 }
 
diff --git a/src/domain/firearms/validate.ts b/src/domain/firearms/validate.ts
index 9256eb50..55d25902 100644
--- a/src/domain/firearms/validate.ts
+++ b/src/domain/firearms/validate.ts
@@ -10,8 +10,26 @@
  * request), and the `unspecified` sentinel yields `typeRequired`/`actionRequired`
  * (R7 — a real category must be chosen on every write, including edits of a
  * backfilled row).
+ *
+ * `acquiredDate` is nullable and, when present, must be a real ISO calendar
+ * date, and not more than `FUTURE_DATE_TOLERANCE_DAYS` after `asOf`
+ * (service-intervals plan R22, mirrors `accessories.acquiredDate`'s own
+ * validator exactly — that column was added later on this branch). Unlike
+ * `magazine`/`ammo`'s acquired date — which the service layer persists
+ * unvalidated — a firearm's feeds the
+ * service-interval origin date (KTD9): `measureFrom` in `derive.ts` is built
+ * from it directly, so a FUTURE acquired date would make every rule's
+ * elapsed-days count clamp to 0 forever, silently freezing its due state
+ * until the clock caught up (F3 fix). A malformed value is rejected here
+ * rather than left to the Postgres `date` cast.
  */
 
+import { differenceInCalendarDays, parseISO } from "date-fns";
+import {
+  FUTURE_DATE_TOLERANCE_DAYS,
+  ISO_DATE,
+  isRealCalendarDate,
+} from "@/src/lib/dates";
 import { isFirearmAction, isFirearmType, UNSPECIFIED } from "./constants";
 
 export type FirearmValidationCode =
@@ -20,16 +38,33 @@ export type FirearmValidationCode =
   | "invalidType"
   | "invalidAction"
   | "typeRequired"
-  | "actionRequired";
+  | "actionRequired"
+  | "invalidAcquiredDate"
+  | "acquiredDateInFuture";
 
 export interface FirearmInput {
   name: string;
   caliber: string;
   type: string;
   action: string;
+  /** ISO calendar date (`YYYY-MM-DD`), or null/undefined when unset. */
+  acquiredDate?: string | null;
 }
 
-export function validateFirearm(input: FirearmInput): FirearmValidationCode[] {
+/**
+ * `asOf` is the reference "now" the not-in-the-future `acquiredDate` check
+ * compares against — an explicit parameter (default `new Date()`, the
+ * server's clock) so this stays a pure, deterministic function for tests,
+ * matching `validateServicedOn`'s shape. The same one-day tolerance
+ * (`FUTURE_DATE_TOLERANCE_DAYS`) applies for the same reason as
+ * `validateServicedOn`: `asOf` is the SERVER's clock, and a submitter whose
+ * local calendar day genuinely runs ahead of it must not be rejected for
+ * submitting their own today.
+ */
+export function validateFirearm(
+  input: FirearmInput,
+  asOf: Date = new Date(),
+): FirearmValidationCode[] {
   const codes: FirearmValidationCode[] = [];
   if (input.name.trim() === "") codes.push("emptyName");
   if (input.caliber.trim() === "") codes.push("emptyCaliber");
@@ -37,5 +72,16 @@ export function validateFirearm(input: FirearmInput): FirearmValidationCode[] {
   else if (input.type === UNSPECIFIED) codes.push("typeRequired");
   if (!isFirearmAction(input.action)) codes.push("invalidAction");
   else if (input.action === UNSPECIFIED) codes.push("actionRequired");
+  if (input.acquiredDate !== null && input.acquiredDate !== undefined) {
+    const date = input.acquiredDate.trim();
+    if (date === "" || !ISO_DATE.test(date) || !isRealCalendarDate(date)) {
+      codes.push("invalidAcquiredDate");
+    } else if (
+      differenceInCalendarDays(parseISO(date), asOf) >
+      FUTURE_DATE_TOLERANCE_DAYS
+    ) {
+      codes.push("acquiredDateInFuture");
+    }
+  }
   return codes;
 }
diff --git a/src/domain/inventory-log/__tests__/last-inventoried.test.ts b/src/domain/inventory-log/__tests__/last-inventoried.test.ts
index 4be0b91c..7324c6f0 100644
--- a/src/domain/inventory-log/__tests__/last-inventoried.test.ts
+++ b/src/domain/inventory-log/__tests__/last-inventoried.test.ts
@@ -74,14 +74,9 @@ describe("loadLastInventoriedBatch (U1)", () => {
       eventType: "inventoried",
       occurredAt: new Date("2026-06-01T00:00:00.000Z"),
     });
-    await makeLogEntry("firearm", fa.id, {
-      actorId: owner,
-      eventType: "cleaned",
-      occurredAt: new Date("2026-07-01T00:00:00.000Z"),
-    });
 
-    // A magazine-scoped call must ignore both the firearm's inventoried entry
-    // and its cleaned entry (wrong parentType entirely).
+    // A magazine-scoped call must ignore the firearm's entry entirely (wrong
+    // parentType), even though both share "inventoried" as their eventType.
     const result = await loadLastInventoriedBatch(db, "magazine", [
       mag.id,
       fa.id,
@@ -89,7 +84,7 @@ describe("loadLastInventoriedBatch (U1)", () => {
     expect(result.get(mag.id)?.toISOString()).toBe("2026-01-01T00:00:00.000Z");
     expect(result.has(fa.id)).toBe(false);
 
-    // A firearm-scoped call sees only its own inventoried entry, not cleaned.
+    // A firearm-scoped call sees only its own entry.
     const firearmResult = await loadLastInventoriedBatch(db, "firearm", [
       fa.id,
     ]);
diff --git a/src/domain/inventory-log/__tests__/service.test.ts b/src/domain/inventory-log/__tests__/service.test.ts
index 58b4b544..6e59857b 100644
--- a/src/domain/inventory-log/__tests__/service.test.ts
+++ b/src/domain/inventory-log/__tests__/service.test.ts
@@ -37,13 +37,13 @@ describe("inventory-log service (U3)", () => {
     await createLogEntry(owner, {
       parentType: "firearm",
       parentId: fa.id,
-      eventType: "cleaned",
+      eventType: "inventoried",
       occurredAt: "2026-01-01T00:00:00.000Z",
     });
     await createLogEntry(owner, {
       parentType: "firearm",
       parentId: fa.id,
-      eventType: "lubed",
+      eventType: "inventoried",
       occurredAt: "2026-03-01T00:00:00.000Z",
     });
     await createLogEntry(owner, {
@@ -54,10 +54,10 @@ describe("inventory-log service (U3)", () => {
     });
 
     const entries = await listLogForParent(owner, "firearm", fa.id);
-    expect(entries.map((e) => e.eventType)).toEqual([
-      "lubed",
-      "inventoried",
-      "cleaned",
+    expect(entries.map((e) => e.occurredAt.toISOString())).toEqual([
+      "2026-03-01T00:00:00.000Z",
+      "2026-02-01T00:00:00.000Z",
+      "2026-01-01T00:00:00.000Z",
     ]);
   });
 
@@ -95,7 +95,7 @@ describe("inventory-log service (U3)", () => {
     const created = await createLogEntry(editor, {
       parentType: "firearm",
       parentId: fa.id,
-      eventType: "cleaned",
+      eventType: "inventoried",
       occurredAt: "2026-01-01T00:00:00.000Z",
     });
     expect(created.actorId).toBe(editor);
@@ -148,7 +148,7 @@ describe("inventory-log service (U3)", () => {
       createLogEntry(viewer, {
         parentType: "firearm",
         parentId: fa.id,
-        eventType: "cleaned",
+        eventType: "inventoried",
         occurredAt: "2026-01-01T00:00:00.000Z",
       }),
     ).rejects.toBeInstanceOf(NotAuthorizedError);
@@ -160,7 +160,7 @@ describe("inventory-log service (U3)", () => {
       createLogEntry(stranger, {
         parentType: "firearm",
         parentId: fa.id,
-        eventType: "cleaned",
+        eventType: "inventoried",
         occurredAt: "2026-01-01T00:00:00.000Z",
       }),
     ).rejects.toBeInstanceOf(NotFoundError);
@@ -169,26 +169,29 @@ describe("inventory-log service (U3)", () => {
     ).rejects.toBeInstanceOf(NotFoundError);
   });
 
-  test("covers AE2/R3: cleaned on a magazine throws ValidationError and writes no row", async () => {
-    const mag = await makeMagazine(owner);
+  // Covers R13/KTD1/KTD7 (service-intervals plan, U5): cleaned/lubed are
+  // retired event types entirely, not merely invalid on a magazine — a
+  // firearm parent throws the same ValidationError a magazine always did.
+  test("covers R13: cleaned throws ValidationError and writes no row (retired event type)", async () => {
+    const fa = await makeFirearm(owner);
     await expect(
       createLogEntry(owner, {
-        parentType: "magazine",
-        parentId: mag.id,
+        parentType: "firearm",
+        parentId: fa.id,
         eventType: "cleaned",
         occurredAt: "2026-01-01T00:00:00.000Z",
       }),
     ).rejects.toBeInstanceOf(ValidationError);
-    const entries = await listLogForParent(owner, "magazine", mag.id);
+    const entries = await listLogForParent(owner, "firearm", fa.id);
     expect(entries).toHaveLength(0);
   });
 
-  test("R3 backstop: a raw insert with an invalid (parent_type, event_type) pair is rejected by the DB CHECK", async () => {
-    const mag = await makeMagazine(owner);
+  test("R3 backstop: the DB rejects a direct insert of a retired 'cleaned' row for a firearm after the CHECK was narrowed (U5)", async () => {
+    const fa = await makeFirearm(owner);
     await expectRejects(() =>
       db.insert(inventoryLog).values({
-        parentType: "magazine",
-        parentId: mag.id,
+        parentType: "firearm",
+        parentId: fa.id,
         eventType: "cleaned",
         actorId: owner,
       }),
@@ -200,7 +203,7 @@ describe("inventory-log service (U3)", () => {
     await createLogEntry(owner, {
       parentType: "firearm",
       parentId: fa.id,
-      eventType: "cleaned",
+      eventType: "inventoried",
       occurredAt: "2026-01-01T00:00:00.000Z",
     });
     await db.delete(firearm).where(eq(firearm.id, fa.id));
@@ -340,7 +343,7 @@ describe("inventory-log service (U3)", () => {
       const created = await createLogEntry(isolatedGrantee, {
         parentType: "firearm",
         parentId: fa.id,
-        eventType: "cleaned",
+        eventType: "inventoried",
         occurredAt: "2026-01-01T00:00:00.000Z",
       });
       expect(created.actorId).toBe(isolatedGrantee);
diff --git a/src/domain/inventory-log/__tests__/validate.test.ts b/src/domain/inventory-log/__tests__/validate.test.ts
index c0f27d75..33a1edda 100644
--- a/src/domain/inventory-log/__tests__/validate.test.ts
+++ b/src/domain/inventory-log/__tests__/validate.test.ts
@@ -9,10 +9,8 @@ const base: LogEntryInput = {
 };
 
 describe("validateLogEntry", () => {
-  test("firearm accepts inventoried, cleaned, and lubed", () => {
-    for (const eventType of ["inventoried", "cleaned", "lubed"]) {
-      expect(validateLogEntry({ ...base, eventType })).toEqual([]);
-    }
+  test("firearm accepts inventoried", () => {
+    expect(validateLogEntry({ ...base, eventType: "inventoried" })).toEqual([]);
   });
 
   test("magazine accepts inventoried", () => {
@@ -25,8 +23,14 @@ describe("validateLogEntry", () => {
     ).toEqual([]);
   });
 
-  test("magazine rejects cleaned and lubed", () => {
+  // Covers R13/KTD1/KTD7 (service-intervals plan, U5): cleaned/lubed are
+  // retired firearm event types, converted to service events. Neither parent
+  // family accepts them any more.
+  test("firearm and magazine both reject cleaned and lubed (retired, U5)", () => {
     for (const eventType of ["cleaned", "lubed"]) {
+      expect(validateLogEntry({ ...base, eventType })).toContain(
+        "invalidEventType",
+      );
       expect(
         validateLogEntry({ ...base, parentType: "magazine", eventType }),
       ).toContain("invalidEventType");
diff --git a/src/domain/inventory-log/constants.ts b/src/domain/inventory-log/constants.ts
index 9b691487..779ad881 100644
--- a/src/domain/inventory-log/constants.ts
+++ b/src/domain/inventory-log/constants.ts
@@ -13,8 +13,14 @@
 
 import type { ParentType } from "@/src/auth/visibility";
 
-/** Event types valid for a firearm parent (R2). */
-export const FIREARM_LOG_EVENTS = ["inventoried", "cleaned", "lubed"] as const;
+/**
+ * Event types valid for a firearm parent (R2). `cleaned` and `lubed` were
+ * retired here by the service-intervals plan's U5 (R13) — logging service
+ * against a named `service_rule` (see `src/domain/service-intervals/`) is now
+ * the single way to record either act, and every pre-existing `cleaned`/
+ * `lubed` row was converted to a `service_event` by that unit's migration.
+ */
+export const FIREARM_LOG_EVENTS = ["inventoried"] as const;
 
 /** Event types valid for a magazine parent (R2). */
 export const MAGAZINE_LOG_EVENTS = ["inventoried"] as const;
diff --git a/src/domain/range-sessions/validate.ts b/src/domain/range-sessions/validate.ts
index 723bd951..9ba003ce 100644
--- a/src/domain/range-sessions/validate.ts
+++ b/src/domain/range-sessions/validate.ts
@@ -5,6 +5,8 @@
  * calendar date (KTD5 — any valid date, no future-date restriction in v1).
  */
 
+import { ISO_DATE, isRealCalendarDate } from "@/src/lib/dates";
+
 export type RangeSessionValidationCode =
   | "invalidRoundsFired"
   | "emptyDate"
@@ -18,20 +20,6 @@ export interface RangeSessionInput {
   notes?: string;
 }
 
-const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
-
-/**
- * True only for a real calendar date. `Date.parse` NORMALIZES day overflow
- * (e.g. `2026-02-31` → Mar 3) instead of returning NaN, so a round-trip compare
- * against the UTC-normalized ISO date is what rejects impossible days — the
- * Postgres `date` cast would otherwise reject them downstream.
- */
-function isRealCalendarDate(date: string): boolean {
-  const parsed = Date.parse(date);
-  if (Number.isNaN(parsed)) return false;
-  return new Date(parsed).toISOString().slice(0, 10) === date;
-}
-
 export function validateRangeSession(
   input: RangeSessionInput,
 ): RangeSessionValidationCode[] {
diff --git a/src/domain/service-intervals/__tests__/actor-names.test.ts b/src/domain/service-intervals/__tests__/actor-names.test.ts
new file mode 100644
index 00000000..5262348e
--- /dev/null
+++ b/src/domain/service-intervals/__tests__/actor-names.test.ts
@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import { UNKNOWN_ACTOR_LABEL, withActorNames } from "../actor-names";
+import type { ServiceEventRow } from "../events-service";
+
+/**
+ * `withActorNames` unit tests (service-intervals plan). No fixture users are
+ * created here on purpose — every case below constructs its own
+ * `ServiceEventRow`-shaped object rather than persisting one, since
+ * `withActorNames` only ever reads the fields on the row it's handed; the
+ * lookup-miss case in particular needs an `actorId` that is well-formed but
+ * matches no `user` row, which is simplest to model directly rather than by
+ * creating and deleting a real account.
+ */
+
+function makeEvent(overrides: Partial<ServiceEventRow> = {}): ServiceEventRow {
+  return {
+    id: "11111111-1111-1111-1111-111111111111",
+    firearmId: "22222222-2222-2222-2222-222222222222",
+    accessoryId: null,
+    ruleName: "Cleaning",
+    servicedOn: "2026-01-01",
+    actorId: null,
+    notes: "",
+    createdAt: new Date(2026, 0, 1),
+    ...overrides,
+  };
+}
+
+describe("service-intervals actor-names withActorNames", () => {
+  test("a null actorId resolves to UNKNOWN_ACTOR_LABEL", async () => {
+    const [entry] = await withActorNames([makeEvent({ actorId: null })]);
+    expect(entry.actorName).toBe(UNKNOWN_ACTOR_LABEL);
+  });
+
+  test("a non-null actorId whose account no longer exists resolves to UNKNOWN_ACTOR_LABEL, never the raw id", async () => {
+    const missingActorId = "99999999-9999-9999-9999-999999999999";
+    const [entry] = await withActorNames([
+      makeEvent({ actorId: missingActorId }),
+    ]);
+    expect(entry.actorName).toBe(UNKNOWN_ACTOR_LABEL);
+    expect(entry.actorName).not.toBe(missingActorId);
+  });
+});
diff --git a/src/domain/service-intervals/__tests__/backlog.test.ts b/src/domain/service-intervals/__tests__/backlog.test.ts
new file mode 100644
index 00000000..78618875
--- /dev/null
+++ b/src/domain/service-intervals/__tests__/backlog.test.ts
@@ -0,0 +1,295 @@
+import { describe, expect, test } from "bun:test";
+import { buildServiceBacklog } from "../backlog";
+import type { ItemDueEntry, RuleDueState } from "../due-service";
+
+/**
+ * Pure unit tests for `buildServiceBacklog` (R16/R19 surface, U9-adjacent).
+ * No DB — `ItemDueEntry`/`RuleDueState` fixtures are hand-built, matching how
+ * `derive.test.ts` and `due-service.test.ts` construct these shapes.
+ */
+
+function rule(name: string, due: boolean): RuleDueState {
+  const base = {
+    name,
+    intervalDays: null,
+    intervalSessions: null,
+    intervalRounds: null,
+    inheritanceState: "inherited" as const,
+    measureFrom: new Date(2026, 0, 1),
+    counts: { days: 0, sessions: 0, rounds: 0 },
+  };
+  // Branched (rather than a flat `due, trippedAxis: due ? "days" : null`)
+  // because `RuleDueState` is now a discriminated union (Fix 1): only this
+  // shape lets TypeScript confirm the fixture actually matches what
+  // `isDue` ever produces, rather than a boolean-typed `due` masking a
+  // `due: true` + `trippedAxis: null` pairing the real code can't build.
+  return due
+    ? { ...base, due: true, trippedAxis: "days" }
+    : { ...base, due: false, trippedAxis: null };
+}
+
+describe("buildServiceBacklog", () => {
+  test("one row per DUE rule, naming the item and the rule", () => {
+    const entries: ItemDueEntry[] = [
+      {
+        parentType: "firearm",
+        parentId: "fa-1",
+        rules: [rule("Cleaning", true), rule("Barrel", false)],
+      },
+    ];
+
+    const rows = buildServiceBacklog(
+      entries,
+      new Map([["fa-1", "Interval Rifle One"]]),
+      new Map(),
+      new Set(["fa-1"]),
+    );
+
+    expect(rows).toEqual([
+      {
+        parentType: "firearm",
+        parentId: "fa-1",
+        itemName: "Interval Rifle One",
+        ruleName: "Cleaning",
+      },
+    ]);
+  });
+
+  test("skips items with no due rules entirely", () => {
+    const entries: ItemDueEntry[] = [
+      {
+        parentType: "firearm",
+        parentId: "fa-1",
+        rules: [rule("Cleaning", false)],
+      },
+    ];
+
+    expect(
+      buildServiceBacklog(
+        entries,
+        new Map([["fa-1", "Rifle"]]),
+        new Map(),
+        new Set(["fa-1"]),
+      ),
+    ).toEqual([]);
+  });
+
+  test("covers accessories via the accessory name map, independent of firearm names", () => {
+    const entries: ItemDueEntry[] = [
+      {
+        parentType: "accessory",
+        parentId: "acc-1",
+        rules: [rule("Lens", true)],
+      },
+    ];
+
+    const rows = buildServiceBacklog(
+      entries,
+      new Map(),
+      new Map([["acc-1", "Vortex Scope"]]),
+      new Set(),
+    );
+
+    expect(rows).toEqual([
+      {
+        parentType: "accessory",
+        parentId: "acc-1",
+        itemName: "Vortex Scope",
+        ruleName: "Lens",
+      },
+    ]);
+  });
+
+  test("an item missing from its name map falls back to a generic label rather than throwing", () => {
+    const entries: ItemDueEntry[] = [
+      {
+        parentType: "firearm",
+        parentId: "fa-unknown",
+        rules: [rule("Cleaning", true)],
+      },
+    ];
+
+    const rows = buildServiceBacklog(
+      entries,
+      new Map(),
+      new Map(),
+      new Set(["fa-unknown"]),
+    );
+
+    expect(rows[0]?.itemName).toBe("Unknown item");
+  });
+
+  test("sorts rows by item name, then by rule name, for a stable display order", () => {
+    const entries: ItemDueEntry[] = [
+      {
+        parentType: "firearm",
+        parentId: "fa-2",
+        rules: [rule("Cleaning", true), rule("Barrel", true)],
+      },
+      {
+        parentType: "firearm",
+        parentId: "fa-1",
+        rules: [rule("Cleaning", true)],
+      },
+    ];
+    const names = new Map([
+      ["fa-1", "Alpha Rifle"],
+      ["fa-2", "Beta Rifle"],
+    ]);
+
+    const rows = buildServiceBacklog(
+      entries,
+      names,
+      new Map(),
+      new Set(["fa-1", "fa-2"]),
+    );
+
+    expect(rows.map((r) => `${r.itemName}:${r.ruleName}`)).toEqual([
+      "Alpha Rifle:Cleaning",
+      "Beta Rifle:Barrel",
+      "Beta Rifle:Cleaning",
+    ]);
+  });
+
+  test("multiple due rules on the same item each produce their own row", () => {
+    const entries: ItemDueEntry[] = [
+      {
+        parentType: "firearm",
+        parentId: "fa-1",
+        rules: [
+          rule("Cleaning", true),
+          rule("Barrel", true),
+          rule("Recoil spring", false),
+        ],
+      },
+    ];
+
+    const rows = buildServiceBacklog(
+      entries,
+      new Map([["fa-1", "Rifle"]]),
+      new Map(),
+      new Set(["fa-1"]),
+    );
+
+    expect(rows).toHaveLength(2);
+    expect(rows.map((r) => r.ruleName).sort()).toEqual(["Barrel", "Cleaning"]);
+  });
+
+  test("empty entries yields an empty backlog, not an error", () => {
+    expect(buildServiceBacklog([], new Map(), new Map(), new Set())).toEqual(
+      [],
+    );
+  });
+
+  // --- Finding 1 (P1): view-only grantees must not be offered write rows ---
+
+  test("a firearm absent from actionableFirearmIds (view-only grantee) is excluded from the backlog", () => {
+    const entries: ItemDueEntry[] = [
+      {
+        parentType: "firearm",
+        parentId: "fa-view-only",
+        rules: [rule("Cleaning", true)],
+      },
+    ];
+
+    const rows = buildServiceBacklog(
+      entries,
+      new Map([["fa-view-only", "Shared Rifle"]]),
+      new Map(),
+      new Set(), // actor holds no owner/edit permission on this firearm
+    );
+
+    expect(rows).toEqual([]);
+  });
+
+  test("a firearm present in actionableFirearmIds (edit-grantee) is included in the backlog", () => {
+    const entries: ItemDueEntry[] = [
+      {
+        parentType: "firearm",
+        parentId: "fa-edit",
+        rules: [rule("Cleaning", true)],
+      },
+    ];
+
+    const rows = buildServiceBacklog(
+      entries,
+      new Map([["fa-edit", "Shared Rifle"]]),
+      new Map(),
+      new Set(["fa-edit"]), // actor holds edit permission
+    );
+
+    expect(rows).toEqual([
+      {
+        parentType: "firearm",
+        parentId: "fa-edit",
+        itemName: "Shared Rifle",
+        ruleName: "Cleaning",
+      },
+    ]);
+  });
+
+  test("a view-only firearm is excluded while the actor's own actionable firearm still appears", () => {
+    const entries: ItemDueEntry[] = [
+      {
+        parentType: "firearm",
+        parentId: "fa-own",
+        rules: [rule("Cleaning", true)],
+      },
+      {
+        parentType: "firearm",
+        parentId: "fa-view-only",
+        rules: [rule("Barrel", true)],
+      },
+    ];
+
+    const rows = buildServiceBacklog(
+      entries,
+      new Map([
+        ["fa-own", "My Rifle"],
+        ["fa-view-only", "Shared Rifle"],
+      ]),
+      new Map(),
+      new Set(["fa-own"]),
+    );
+
+    expect(rows).toEqual([
+      {
+        parentType: "firearm",
+        parentId: "fa-own",
+        itemName: "My Rifle",
+        ruleName: "Cleaning",
+      },
+    ]);
+  });
+
+  test("an accessory belonging to someone else never appears, regardless of actionableFirearmIds", () => {
+    const entries: ItemDueEntry[] = [
+      {
+        parentType: "accessory",
+        parentId: "acc-not-mine",
+        rules: [rule("Lens", true)],
+      },
+    ];
+
+    // actionableFirearmIds only ever governs firearm rows (KTD3: accessory
+    // service is owner-only throughout, and `listDueForVisibleCollection`
+    // never surfaces another owner's accessory in the first place) — an
+    // empty set here proves the accessory row's inclusion doesn't depend on
+    // it at all.
+    const rows = buildServiceBacklog(
+      entries,
+      new Map(),
+      new Map([["acc-not-mine", "Someone Else's Scope"]]),
+      new Set(),
+    );
+
+    expect(rows).toEqual([
+      {
+        parentType: "accessory",
+        parentId: "acc-not-mine",
+        itemName: "Someone Else's Scope",
+        ruleName: "Lens",
+      },
+    ]);
+  });
+});
diff --git a/src/domain/service-intervals/__tests__/derive.test.ts b/src/domain/service-intervals/__tests__/derive.test.ts
new file mode 100644
index 00000000..4c4f7910
--- /dev/null
+++ b/src/domain/service-intervals/__tests__/derive.test.ts
@@ -0,0 +1,261 @@
+import { describe, expect, test } from "bun:test";
+import {
+  type DefaultRule,
+  type ElapsedCounts,
+  elapsedCounts,
+  type ItemRule,
+  isDue,
+  resolveEffectiveRules,
+  type SessionRow,
+  type Thresholds,
+} from "../derive";
+
+// Pure derivation core (U2) — no DB. Date fixtures are always built with
+// `new Date(y, monthIndex, d)` (local frame), never UTC `...Z` literals, per
+// docs/solutions/test-failures/timezone-fragile-date-boundary-tests.md and
+// KTD5. This file is run under UTC, TZ=Asia/Tokyo, and TZ=America/New_York.
+
+function localDate(year: number, monthIndex: number, day: number): Date {
+  return new Date(year, monthIndex, day);
+}
+
+describe("resolveEffectiveRules", () => {
+  test("covers AE1: inheritance survives an unrelated override", () => {
+    const defaults: DefaultRule[] = [
+      {
+        name: "Cleaning",
+        intervalDays: null,
+        intervalSessions: null,
+        intervalRounds: 500,
+      },
+      {
+        name: "Barrel",
+        intervalDays: null,
+        intervalSessions: null,
+        intervalRounds: 5000,
+      },
+    ];
+    const itemRules: ItemRule[] = [
+      {
+        name: "Barrel",
+        suppressed: false,
+        intervalDays: null,
+        intervalSessions: null,
+        intervalRounds: 4000,
+      },
+    ];
+
+    const resolved = resolveEffectiveRules(defaults, itemRules);
+    const barrel = resolved.find((r) => r.name === "Barrel");
+    const cleaning = resolved.find((r) => r.name === "Cleaning");
+
+    expect(barrel).toMatchObject({
+      intervalRounds: 4000,
+      inheritanceState: "overridden",
+    });
+    expect(cleaning).toMatchObject({
+      intervalRounds: 500,
+      inheritanceState: "inherited",
+    });
+
+    // Raising the default Barrel to 6000 leaves the override standing.
+    const raisedDefaults: DefaultRule[] = [
+      defaults[0],
+      { ...defaults[1], intervalRounds: 6000 },
+    ];
+    const resolvedAfterRaise = resolveEffectiveRules(raisedDefaults, itemRules);
+    const barrelAfterRaise = resolvedAfterRaise.find(
+      (r) => r.name === "Barrel",
+    );
+    expect(barrelAfterRaise?.intervalRounds).toBe(4000);
+    expect(barrelAfterRaise?.inheritanceState).toBe("overridden");
+  });
+
+  test("covers AE5: a suppressed item rule removes the matching default entirely", () => {
+    const defaults: DefaultRule[] = [
+      {
+        name: "Cleaning",
+        intervalDays: null,
+        intervalSessions: null,
+        intervalRounds: 500,
+      },
+    ];
+    const itemRules: ItemRule[] = [
+      {
+        name: "Cleaning",
+        suppressed: true,
+        intervalDays: null,
+        intervalSessions: null,
+        intervalRounds: null,
+      },
+    ];
+
+    expect(resolveEffectiveRules(defaults, itemRules)).toEqual([]);
+  });
+
+  test("an item rule with no matching default resolves as item-only and is unaffected by any default", () => {
+    const defaults: DefaultRule[] = [
+      {
+        name: "Cleaning",
+        intervalDays: null,
+        intervalSessions: null,
+        intervalRounds: 500,
+      },
+    ];
+    const itemRules: ItemRule[] = [
+      {
+        name: "Recoil Spring",
+        suppressed: false,
+        intervalDays: null,
+        intervalSessions: null,
+        intervalRounds: 3000,
+      },
+    ];
+
+    const resolved = resolveEffectiveRules(defaults, itemRules);
+    expect(resolved).toHaveLength(2);
+    expect(resolved.find((r) => r.name === "Recoil Spring")).toMatchObject({
+      inheritanceState: "item-only",
+      intervalRounds: 3000,
+    });
+  });
+
+  test("a suppressed item rule with no matching default contributes nothing and raises no error", () => {
+    const itemRules: ItemRule[] = [
+      {
+        name: "Ghost",
+        suppressed: true,
+        intervalDays: null,
+        intervalSessions: null,
+        intervalRounds: null,
+      },
+    ];
+
+    expect(resolveEffectiveRules([], itemRules)).toEqual([]);
+  });
+
+  test("empty defaults and empty item rules resolve to an empty rule set, not an error", () => {
+    expect(resolveEffectiveRules([], [])).toEqual([]);
+  });
+});
+
+describe("isDue", () => {
+  test("covers AE2: first threshold to trip wins", () => {
+    const thresholds: Thresholds = {
+      intervalDays: 180,
+      intervalSessions: null,
+      intervalRounds: 500,
+    };
+    const counts: ElapsedCounts = { days: 20, sessions: 0, rounds: 640 };
+
+    const result = isDue(thresholds, counts);
+    expect(result.due).toBe(true);
+    expect(result.trippedAxis).toBe("rounds");
+  });
+
+  test("a rule setting only days is not due when only rounds have accumulated past a value the rule does not set", () => {
+    const thresholds: Thresholds = {
+      intervalDays: 180,
+      intervalSessions: null,
+      intervalRounds: null,
+    };
+    const counts: ElapsedCounts = { days: 10, sessions: 5, rounds: 10_000 };
+
+    expect(isDue(thresholds, counts)).toEqual({
+      due: false,
+      trippedAxis: null,
+    });
+  });
+
+  test("a rule exactly at its threshold is due — met-or-exceeded, not exceeded", () => {
+    const thresholds: Thresholds = {
+      intervalDays: null,
+      intervalSessions: null,
+      intervalRounds: 500,
+    };
+    const counts: ElapsedCounts = { days: 0, sessions: 0, rounds: 500 };
+
+    expect(isDue(thresholds, counts).due).toBe(true);
+  });
+
+  // F8: the sessions axis specifically, as the tripped axis — previously
+  // asserted only for days (AE2, via rounds) and rounds, never sessions.
+  test("covers F8: the sessions axis trips when only sessions has reached its threshold", () => {
+    const thresholds: Thresholds = {
+      intervalDays: 180,
+      intervalSessions: 5,
+      intervalRounds: 10_000,
+    };
+    const counts: ElapsedCounts = { days: 20, sessions: 6, rounds: 100 };
+
+    expect(isDue(thresholds, counts)).toEqual({
+      due: true,
+      trippedAxis: "sessions",
+    });
+  });
+});
+
+describe("elapsedCounts", () => {
+  test("a session dated the same calendar day as the measure-from date does not count; one day later does", () => {
+    const measureFrom = localDate(2026, 0, 15);
+    const sessions: SessionRow[] = [
+      { date: localDate(2026, 0, 15), roundsFired: 50 },
+      { date: localDate(2026, 0, 16), roundsFired: 30 },
+    ];
+    const asOf = localDate(2026, 0, 20);
+
+    const counts = elapsedCounts(measureFrom, sessions, asOf);
+    expect(counts.sessions).toBe(1);
+    expect(counts.rounds).toBe(30);
+  });
+
+  test("folds multiple post-measure-from sessions into total sessions and rounds", () => {
+    const measureFrom = localDate(2026, 0, 1);
+    const sessions: SessionRow[] = [
+      { date: localDate(2026, 0, 5), roundsFired: 100 },
+      { date: localDate(2026, 0, 10), roundsFired: 200 },
+      { date: localDate(2025, 11, 31), roundsFired: 999 }, // before measure-from
+    ];
+    const asOf = localDate(2026, 0, 15);
+
+    const counts = elapsedCounts(measureFrom, sessions, asOf);
+    expect(counts.sessions).toBe(2);
+    expect(counts.rounds).toBe(300);
+  });
+
+  test("elapsed days matches calendar days regardless of runner timezone", () => {
+    const measureFrom = localDate(2026, 0, 1);
+    const asOf = localDate(2026, 0, 21);
+
+    const counts = elapsedCounts(measureFrom, [], asOf);
+    expect(counts.days).toBe(20);
+  });
+
+  test("an empty session list still resolves elapsed days", () => {
+    const measureFrom = localDate(2026, 0, 1);
+    const asOf = localDate(2026, 0, 1);
+
+    expect(elapsedCounts(measureFrom, [], asOf)).toEqual({
+      days: 0,
+      sessions: 0,
+      rounds: 0,
+    });
+  });
+
+  // F4: a future-dated range session must not inflate today's counts. Range
+  // sessions are deliberately allowed a future date by their own validation
+  // (unrelated, unchanged) — `elapsedCounts` is what must not count one
+  // until `asOf` actually reaches it.
+  test("covers F4: a session dated after asOf contributes neither sessions nor rounds; one dated exactly asOf still counts", () => {
+    const measureFrom = localDate(2026, 0, 1);
+    const asOf = localDate(2026, 0, 15);
+    const sessions: SessionRow[] = [
+      { date: localDate(2026, 0, 15), roundsFired: 40 }, // exactly asOf: counts
+      { date: localDate(2026, 0, 20), roundsFired: 999 }, // after asOf: excluded
+    ];
+
+    const counts = elapsedCounts(measureFrom, sessions, asOf);
+    expect(counts.sessions).toBe(1);
+    expect(counts.rounds).toBe(40);
+  });
+});
diff --git a/src/domain/service-intervals/__tests__/due-service.test.ts b/src/domain/service-intervals/__tests__/due-service.test.ts
new file mode 100644
index 00000000..49fc5f32
--- /dev/null
+++ b/src/domain/service-intervals/__tests__/due-service.test.ts
@@ -0,0 +1,460 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { Pool } from "pg";
+import { createGrant } from "@/src/auth/grants";
+import { db } from "@/src/db/client";
+import { rangeSessionAccessory } from "@/src/db/schema";
+import {
+  createUser,
+  deleteUsers,
+  makeAccessory,
+  makeFirearm,
+  makeRangeSession,
+  makeServiceEvent,
+} from "@/src/test-support/factories";
+import { getItemDueState, listDueForVisibleCollection } from "../due-service";
+import { listServiceHistory, logServiceEvent } from "../events-service";
+import { createItemRule, createServiceRuleDefault } from "../rules-service";
+
+/**
+ * Due-service integration tests (service-intervals plan, U4). Each test
+ * creates its own owner(s), matching the isolation style established in
+ * `rules-service.test.ts`. Date fixtures are always built with
+ * `new Date(y, monthIndex, d)` (local frame), never UTC `...Z` literals
+ * (KTD5, docs/solutions/test-failures/timezone-fragile-date-boundary-tests.md).
+ */
+
+function localDate(year: number, monthIndex: number, day: number): Date {
+  return new Date(year, monthIndex, day);
+}
+
+/**
+ * Counts every SQL round trip issued through `pg`'s `Pool.prototype.query`
+ * while `fn` runs — patched at the shared class prototype (not the
+ * lazy-proxy `db`/`pool` exports in `src/db/client.ts`, whose `set` trap
+ * isn't overridden and so wouldn't reach the real, already-constructed pool
+ * instance drizzle holds). `drizzle-orm/node-postgres`'s session always
+ * calls `this.client.query(...)` for a non-transactional query — `client`
+ * being the pool itself outside a transaction — so this captures exactly
+ * the top-level query count `listDueForVisibleCollection` issues.
+ */
+async function countPoolQueries<T>(
+  fn: () => Promise<T>,
+): Promise<{ result: T; count: number }> {
+  const original = Pool.prototype.query;
+  let count = 0;
+  Pool.prototype.query = function (
+    this: Pool,
+    ...args: Parameters<typeof original>
+  ) {
+    count += 1;
+    // biome-ignore lint/suspicious/noExplicitAny: passthrough to the original overloaded pg method
+    return (original as any).apply(this, args);
+  } as typeof original;
+  try {
+    const result = await fn();
+    return { result, count };
+  } finally {
+    Pool.prototype.query = original;
+  }
+}
+
+describe("service-intervals due-service (U4)", () => {
+  const createdUsers: string[] = [];
+
+  afterAll(async () => {
+    await deleteUsers(...createdUsers);
+  });
+
+  async function newOwner(label: string): Promise<string> {
+    const id = await createUser(label);
+    createdUsers.push(id);
+    return id;
+  }
+
+  test("covers AE3: cold start counts from the acquired date", async () => {
+    const owner = await newOwner("u4ae3");
+    const fa = await makeFirearm(owner, {
+      type: "rifle",
+      acquiredDate: "2026-01-01",
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    await makeRangeSession(fa.id, { date: "2026-01-10", roundsFired: 700 });
+    await makeRangeSession(fa.id, { date: "2026-01-20", roundsFired: 700 });
+
+    const rules = await getItemDueState(
+      owner,
+      "firearm",
+      fa.id,
+      localDate(2026, 0, 31),
+    );
+    const cleaning = rules.find((r) => r.name === "Cleaning");
+
+    expect(cleaning?.due).toBe(true);
+    expect(cleaning?.trippedAxis).toBe("rounds");
+    expect(cleaning?.counts).toEqual({ days: 30, sessions: 2, rounds: 1400 });
+  });
+
+  // Accessory acquiredDate (added during implementation — see the plan's
+  // "Scope added during implementation" note; KTD9 updated to resolve an
+  // accessory's origin the same way a firearm's does). Parallels AE3 above
+  // exactly, on the accessory side, and is the direct proof for the feature:
+  // a backdated accessory reads due on day one where an otherwise-identical
+  // one with no acquired date does not.
+  test("an accessory with a backdated acquired date is due on day one; an otherwise-identical one with no acquired date is not", async () => {
+    const owner = await newOwner("u4accAcquiredColdStart");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const backdated = await makeAccessory(owner, {
+      category: "Optic",
+      currentFirearmId: fa.id,
+      acquiredDate: "2024-01-01",
+    });
+    const undated = await makeAccessory(owner, {
+      category: "Optic",
+      currentFirearmId: fa.id,
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "accessory",
+      category: "Optic",
+      name: "Cleaning",
+      intervalDays: 180,
+    });
+
+    const asOf = localDate(2026, 0, 1);
+    const backdatedRules = await getItemDueState(
+      owner,
+      "accessory",
+      backdated.id,
+      asOf,
+    );
+    const undatedRules = await getItemDueState(
+      owner,
+      "accessory",
+      undated.id,
+      asOf,
+    );
+    const backdatedCleaning = backdatedRules.find((r) => r.name === "Cleaning");
+    const undatedCleaning = undatedRules.find((r) => r.name === "Cleaning");
+
+    expect(backdatedCleaning?.due).toBe(true);
+    expect(backdatedCleaning?.trippedAxis).toBe("days");
+    expect(backdatedCleaning?.measureFrom.getTime()).toBe(
+      localDate(2024, 0, 1).getTime(),
+    );
+    // The undated accessory was just created (its origin is `createdAt`,
+    // effectively "now") — nowhere near 180 days elapsed.
+    expect(undatedCleaning?.due).toBe(false);
+  });
+
+  test("covers AE4: a suppressor mounted on 2 of 5 post-service sessions counts only those two sessions and their rounds", async () => {
+    const owner = await newOwner("u4ae4");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const suppressor = await makeAccessory(owner, {
+      category: "Suppressor",
+      currentFirearmId: fa.id,
+    });
+    await makeServiceEvent(
+      { accessoryId: suppressor.id },
+      { ruleName: "Cleaning", servicedOn: "2026-01-01" },
+    );
+    await createItemRule(owner, "accessory", suppressor.id, {
+      name: "Cleaning",
+      intervalRounds: 1,
+    });
+
+    const sessions = [];
+    for (const date of [
+      "2026-01-05",
+      "2026-01-10",
+      "2026-01-15",
+      "2026-01-20",
+      "2026-01-25",
+    ]) {
+      sessions.push(await makeRangeSession(fa.id, { date, roundsFired: 100 }));
+    }
+    // Snapshot only 2 of the 5 sessions as mounted on the suppressor —
+    // mirrors `snapshotMountedAccessories`' per-session join without going
+    // through mount/unmount cycles the test doesn't otherwise need.
+    await db.insert(rangeSessionAccessory).values([
+      { rangeSessionId: sessions[1].id, accessoryId: suppressor.id },
+      { rangeSessionId: sessions[3].id, accessoryId: suppressor.id },
+    ]);
+
+    const rules = await getItemDueState(
+      owner,
+      "accessory",
+      suppressor.id,
+      localDate(2026, 0, 31),
+    );
+    const cleaning = rules.find((r) => r.name === "Cleaning");
+
+    expect(cleaning?.counts.sessions).toBe(2);
+    expect(cleaning?.counts.rounds).toBe(200);
+  });
+
+  test("covers AE6: a firearm with a service event three months old measures from that date, and the event appears in history", async () => {
+    const owner = await newOwner("u4ae6");
+    const fa = await makeFirearm(owner, {
+      type: "rifle",
+      acquiredDate: "2025-01-01",
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    // Stands in for a U5-converted `cleaned` entry — the resulting
+    // service_event row is identical either way.
+    await makeServiceEvent(
+      { firearmId: fa.id },
+      { ruleName: "Cleaning", servicedOn: "2026-01-01" },
+    );
+
+    const rules = await getItemDueState(
+      owner,
+      "firearm",
+      fa.id,
+      localDate(2026, 3, 1), // April 1 — three months after the Jan 1 event
+    );
+    const cleaning = rules.find((r) => r.name === "Cleaning");
+    expect(cleaning?.measureFrom.getTime()).toBe(
+      localDate(2026, 0, 1).getTime(),
+    );
+    expect(cleaning?.counts.days).toBe(90);
+
+    const history = await listServiceHistory(owner, "firearm", fa.id);
+    expect(history.map((e) => e.ruleName)).toContain("Cleaning");
+    expect(history.find((e) => e.ruleName === "Cleaning")?.servicedOn).toBe(
+      "2026-01-01",
+    );
+  });
+
+  test("covers R14: logging service resets that rule's counts to zero and leaves every other rule at its prior counts", async () => {
+    const owner = await newOwner("u4r14");
+    const fa = await makeFirearm(owner, {
+      type: "rifle",
+      acquiredDate: "2026-01-01",
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 10_000,
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Barrel",
+      intervalRounds: 10_000,
+    });
+    await makeRangeSession(fa.id, { date: "2026-02-01", roundsFired: 300 });
+    await makeRangeSession(fa.id, { date: "2026-03-01", roundsFired: 200 });
+
+    const asOf = localDate(2026, 5, 1); // June 1
+    const before = await getItemDueState(owner, "firearm", fa.id, asOf);
+    const barrelBefore = before.find((r) => r.name === "Barrel");
+    expect(barrelBefore?.counts).toEqual({
+      days: 151,
+      sessions: 2,
+      rounds: 500,
+    });
+
+    await logServiceEvent(owner, "firearm", fa.id, {
+      ruleName: "Cleaning",
+      servicedOn: "2026-06-01",
+    });
+
+    const after = await getItemDueState(owner, "firearm", fa.id, asOf);
+    const cleaningAfter = after.find((r) => r.name === "Cleaning");
+    const barrelAfter = after.find((r) => r.name === "Barrel");
+
+    expect(cleaningAfter?.counts).toEqual({ days: 0, sessions: 0, rounds: 0 });
+    expect(barrelAfter?.counts).toEqual(barrelBefore?.counts);
+  });
+
+  test("a firearm with no acquired date measures from its creation date", async () => {
+    const owner = await newOwner("u4noAcquired");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 1,
+    });
+
+    const rules = await getItemDueState(owner, "firearm", fa.id, new Date());
+    const cleaning = rules.find((r) => r.name === "Cleaning");
+    expect(cleaning?.measureFrom.getTime()).toBe(fa.createdAt.getTime());
+  });
+
+  // No `acquiredDate` is set here — with one unset, `createdAt` is still the
+  // fallback origin (KTD9), so this stays valid alongside the acquiredDate
+  // cold-start test above.
+  test("an accessory with no acquired date measures from its creation date, not its installed date", async () => {
+    const owner = await newOwner("u4accCreatedAt");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const acc = await makeAccessory(owner, {
+      category: "Optic",
+      currentFirearmId: fa.id,
+      installedDate: "2020-01-01",
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "accessory",
+      category: "Optic",
+      name: "Cleaning",
+      intervalRounds: 1,
+    });
+
+    const rules = await getItemDueState(owner, "accessory", acc.id, new Date());
+    const cleaning = rules.find((r) => r.name === "Cleaning");
+    expect(cleaning?.measureFrom.getTime()).toBe(acc.createdAt.getTime());
+    expect(cleaning?.measureFrom.getTime()).not.toBe(
+      localDate(2020, 0, 1).getTime(),
+    );
+  });
+
+  test("collection-wide due resolution never surfaces another owner's accessory mounted on a shared firearm (KTD3: accessory service is owner-only throughout)", async () => {
+    const owner = await newOwner("u4collectionAccLeakOwner");
+    const grantee = await newOwner("u4collectionAccLeakGrantee");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const acc = await makeAccessory(owner, {
+      category: "Optic",
+      currentFirearmId: fa.id,
+    });
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: grantee,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "edit",
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "accessory",
+      category: "Optic",
+      name: "Cleaning",
+      intervalRounds: 1,
+    });
+
+    const entries = await listDueForVisibleCollection(grantee, new Date());
+    expect(entries.some((e) => e.parentId === acc.id)).toBe(false);
+  });
+
+  test("collection-wide due resolution over an owner with no defaults anywhere returns an empty result, not an error", async () => {
+    const owner = await newOwner("u4collectionEmpty");
+    await makeFirearm(owner, { type: "rifle" });
+    await makeAccessory(owner, { category: "Optic" });
+
+    const entries = await listDueForVisibleCollection(owner, new Date());
+    expect(entries).toEqual([]);
+  });
+
+  test("collection-wide due resolution includes a shared firearm using its OWNER's defaults, not the viewer's", async () => {
+    const owner = await newOwner("u4collectionOwner");
+    const viewer = await newOwner("u4collectionViewer");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: viewer,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "view",
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    // The viewer's OWN identically-named category default must never leak in.
+    await createServiceRuleDefault(viewer, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 999,
+    });
+
+    const entries = await listDueForVisibleCollection(viewer, new Date());
+    const entry = entries.find((e) => e.parentId === fa.id);
+    expect(entry?.rules.find((r) => r.name === "Cleaning")).toMatchObject({
+      intervalRounds: 500,
+      inheritanceState: "inherited",
+    });
+  });
+
+  test("collection-wide due resolution issues a bounded number of queries regardless of how many items are visible", async () => {
+    const smallOwner = await newOwner("u4boundedSmall");
+    await createServiceRuleDefault(smallOwner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    await makeFirearm(smallOwner, { type: "rifle" });
+    await makeFirearm(smallOwner, { type: "rifle" });
+
+    const largeOwner = await newOwner("u4boundedLarge");
+    await createServiceRuleDefault(largeOwner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    for (let i = 0; i < 15; i += 1) {
+      await makeFirearm(largeOwner, { type: "rifle" });
+    }
+
+    const { result: smallEntries, count: smallCount } = await countPoolQueries(
+      () => listDueForVisibleCollection(smallOwner, new Date()),
+    );
+    const { result: largeEntries, count: largeCount } = await countPoolQueries(
+      () => listDueForVisibleCollection(largeOwner, new Date()),
+    );
+
+    expect(smallEntries).toHaveLength(2);
+    expect(largeEntries).toHaveLength(15);
+    // The whole point: 15 items issue exactly as many queries as 2 — no
+    // per-item query hiding in the loop.
+    expect(largeCount).toBe(smallCount);
+  });
+
+  test("an accessory whose only mounted sessions belong to a firearm the actor cannot see contributes no rounds", async () => {
+    const owner = await newOwner("u4accInvisibleOwner");
+    const stranger = await newOwner("u4accInvisibleStranger");
+    const strangerFa = await makeFirearm(stranger, { type: "rifle" });
+    const acc = await makeAccessory(owner, { category: "Optic" });
+    const session = await makeRangeSession(strangerFa.id, {
+      date: "2026-01-05",
+      roundsFired: 200,
+    });
+    // Direct join insert: simulates a mount snapshot the app itself could
+    // never produce (mounting requires the accessory and firearm to share an
+    // owner, see `authorizeMount`) — this proves the defensive
+    // visible-firearm restriction structurally, mirroring
+    // `accessoryRoundsFired`'s analogous guard in
+    // `src/domain/range-sessions/service.ts`.
+    await db
+      .insert(rangeSessionAccessory)
+      .values({ rangeSessionId: session.id, accessoryId: acc.id });
+    await createServiceRuleDefault(owner, {
+      scope: "accessory",
+      category: "Optic",
+      name: "Cleaning",
+      intervalRounds: 1,
+    });
+
+    const rules = await getItemDueState(
+      owner,
+      "accessory",
+      acc.id,
+      localDate(2026, 1, 1),
+    );
+    const cleaning = rules.find((r) => r.name === "Cleaning");
+    expect(cleaning?.counts.sessions).toBe(0);
+    expect(cleaning?.counts.rounds).toBe(0);
+  });
+});
diff --git a/src/domain/service-intervals/__tests__/events-service.test.ts b/src/domain/service-intervals/__tests__/events-service.test.ts
new file mode 100644
index 00000000..b818b510
--- /dev/null
+++ b/src/domain/service-intervals/__tests__/events-service.test.ts
@@ -0,0 +1,1070 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { and, eq } from "drizzle-orm";
+import { NotAuthorizedError, NotFoundError } from "@/src/auth/errors";
+import { createGrant } from "@/src/auth/grants";
+import { db } from "@/src/db/client";
+import { serviceEvent } from "@/src/db/schema";
+import { ValidationError } from "@/src/domain/errors";
+import {
+  createUser,
+  deleteUsers,
+  makeAccessory,
+  makeFirearm,
+  makeServiceEvent,
+} from "@/src/test-support/factories";
+import { MAX_BULK_SERVICE_ITEMS } from "../constants";
+import { getItemDueState } from "../due-service";
+import {
+  type BulkServiceItem,
+  deleteServiceEvent,
+  listServiceHistory,
+  logServiceEvent,
+  logServiceEventsBulk,
+  resolveServiceEventParent,
+  type ServiceEventUpdateInput,
+  updateServiceEvent,
+} from "../events-service";
+import { createItemRule, updateItemRule } from "../rules-service";
+
+/** Local-frame date fixture (KTD5) — never a UTC `...Z` literal. */
+function localDate(year: number, monthIndex: number, day: number): Date {
+  return new Date(year, monthIndex, day);
+}
+
+/**
+ * Events-service integration tests (service-intervals plan, U4). Each test
+ * creates its own owner(s), matching the isolation style established in
+ * `rules-service.test.ts`.
+ *
+ * F2 fix: `logServiceEvent`/`logServiceEventsBulk` now confirm `ruleName`
+ * resolves against the item's CURRENT effective rule set before writing, so
+ * every test below that expects a successful write first arms the target
+ * rule with `createItemRule` — matching how the real log-service flow only
+ * ever offers a `ruleName` already showing in the item's resolved due state
+ * (`log-service-form.tsx`'s doc comment: "`ruleName` is fixed by which
+ * rule's 'Log service' button opened this form").
+ */
+describe("service-intervals events-service (U4)", () => {
+  const createdUsers: string[] = [];
+
+  afterAll(async () => {
+    await deleteUsers(...createdUsers);
+  });
+
+  async function newOwner(label: string): Promise<string> {
+    const id = await createUser(label);
+    createdUsers.push(id);
+    return id;
+  }
+
+  /** Arms an item-only "Cleaning" rule so a subsequent log-service call resolves (F2). */
+  async function armCleaningRule(
+    owner: string,
+    parentType: "firearm" | "accessory",
+    parentId: string,
+  ): Promise<void> {
+    await createItemRule(owner, parentType, parentId, {
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+  }
+
+  function isoDateOffset(daysFromNow: number): string {
+    const date = new Date();
+    date.setDate(date.getDate() + daysFromNow);
+    return [
+      date.getFullYear(),
+      String(date.getMonth() + 1).padStart(2, "0"),
+      String(date.getDate()).padStart(2, "0"),
+    ].join("-");
+  }
+
+  test("logs a firearm service event recording the given rule, date, and notes", async () => {
+    const owner = await newOwner("u4evOwner");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await armCleaningRule(owner, "firearm", fa.id);
+
+    const event = await logServiceEvent(owner, "firearm", fa.id, {
+      ruleName: "Cleaning",
+      servicedOn: "2026-03-01",
+      notes: "Full field strip",
+    });
+
+    expect(event).toMatchObject({
+      firearmId: fa.id,
+      accessoryId: null,
+      ruleName: "Cleaning",
+      servicedOn: "2026-03-01",
+      actorId: owner,
+      notes: "Full field strip",
+    });
+  });
+
+  test("an edit-grantee can log service on a shared firearm; the event records the grantee as actor", async () => {
+    const owner = await newOwner("u4evOwner2");
+    const editor = await newOwner("u4evEditor");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await armCleaningRule(owner, "firearm", fa.id);
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: editor,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "edit",
+    });
+
+    const event = await logServiceEvent(editor, "firearm", fa.id, {
+      ruleName: "Cleaning",
+      servicedOn: "2026-03-02",
+    });
+
+    expect(event.actorId).toBe(editor);
+  });
+
+  test("a view-grantee on a shared firearm cannot log service", async () => {
+    const owner = await newOwner("u4evOwner3");
+    const viewer = await newOwner("u4evViewer");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: viewer,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "view",
+    });
+
+    await expect(
+      logServiceEvent(viewer, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-03-02",
+      }),
+    ).rejects.toBeInstanceOf(NotAuthorizedError);
+  });
+
+  test("a non-owner cannot log service on an accessory even when they can see the firearm it is mounted to", async () => {
+    const owner = await newOwner("u4evAccOwner");
+    const viewer = await newOwner("u4evAccViewer");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const acc = await makeAccessory(owner, { currentFirearmId: fa.id });
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: viewer,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "edit",
+    });
+
+    await expect(
+      logServiceEvent(viewer, "accessory", acc.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-03-02",
+      }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+
+    const rows = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.accessoryId, acc.id));
+    expect(rows).toHaveLength(0);
+  });
+
+  test("an invalid event (empty rule name, empty date) throws ValidationError and writes no row", async () => {
+    const owner = await newOwner("u4evInvalidOwner");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+
+    await expect(
+      logServiceEvent(owner, "firearm", fa.id, {
+        ruleName: "   ",
+        servicedOn: "",
+      }),
+    ).rejects.toBeInstanceOf(ValidationError);
+
+    const rows = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa.id));
+    expect(rows).toHaveLength(0);
+  });
+
+  test("a servicedOn more than one day in the future throws ValidationError and writes no row (U8 log-service form contract; F1's one-day timezone tolerance)", async () => {
+    const owner = await newOwner("u4evFutureOwner");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await armCleaningRule(owner, "firearm", fa.id);
+
+    await expect(
+      logServiceEvent(owner, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: isoDateOffset(2),
+      }),
+    ).rejects.toMatchObject({ codes: ["servicedOnInFuture"] });
+
+    const rows = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa.id));
+    expect(rows).toHaveLength(0);
+  });
+
+  test("a servicedOn exactly one day in the future is accepted (F1 fix: absorbs a submitter whose local day genuinely runs ahead of the server's)", async () => {
+    const owner = await newOwner("u4evTomorrowOwner");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await armCleaningRule(owner, "firearm", fa.id);
+    const tomorrow = isoDateOffset(1);
+
+    const event = await logServiceEvent(owner, "firearm", fa.id, {
+      ruleName: "Cleaning",
+      servicedOn: tomorrow,
+    });
+
+    expect(event.servicedOn).toBe(tomorrow);
+  });
+
+  test("covers R16: a bulk mark-serviced call across several items writes one event per item-and-rule pair with the given date", async () => {
+    const owner = await newOwner("u4bulkOwner");
+    const fa1 = await makeFirearm(owner, { type: "rifle" });
+    const fa2 = await makeFirearm(owner, { type: "pistol" });
+    const acc = await makeAccessory(owner, { currentFirearmId: fa1.id });
+    await armCleaningRule(owner, "firearm", fa1.id);
+    await armCleaningRule(owner, "firearm", fa2.id);
+    await armCleaningRule(owner, "accessory", acc.id);
+
+    const events = await logServiceEventsBulk(owner, {
+      items: [
+        { parentType: "firearm", parentId: fa1.id, ruleName: "Cleaning" },
+        { parentType: "firearm", parentId: fa2.id, ruleName: "Cleaning" },
+        { parentType: "accessory", parentId: acc.id, ruleName: "Cleaning" },
+      ],
+      servicedOn: "2026-04-01",
+      notes: "Bulk spring clean",
+    });
+
+    expect(events).toHaveLength(3);
+    for (const event of events) {
+      expect(event.servicedOn).toBe("2026-04-01");
+      expect(event.ruleName).toBe("Cleaning");
+      expect(event.notes).toBe("Bulk spring clean");
+    }
+    expect(
+      events
+        .map((e) => e.firearmId)
+        .filter(Boolean)
+        .sort(),
+    ).toEqual([fa1.id, fa2.id].sort());
+    expect(events.find((e) => e.accessoryId === acc.id)).toBeDefined();
+  });
+
+  test("a bulk mark-serviced call containing one unauthorized item writes nothing at all", async () => {
+    const owner = await newOwner("u4bulkUnauthOwner");
+    const stranger = await newOwner("u4bulkUnauthStranger");
+    const ownFa = await makeFirearm(owner, { type: "rifle" });
+    const strangerFa = await makeFirearm(stranger, { type: "rifle" });
+
+    await expect(
+      logServiceEventsBulk(owner, {
+        items: [
+          { parentType: "firearm", parentId: ownFa.id, ruleName: "Cleaning" },
+          {
+            parentType: "firearm",
+            parentId: strangerFa.id,
+            ruleName: "Cleaning",
+          },
+        ],
+        servicedOn: "2026-04-02",
+      }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+
+    const rows = await db
+      .select()
+      .from(serviceEvent)
+      .where(
+        and(
+          eq(serviceEvent.firearmId, ownFa.id),
+          eq(serviceEvent.ruleName, "Cleaning"),
+        ),
+      );
+    expect(rows).toHaveLength(0);
+  });
+
+  test("a view-grantee's bulk mark-serviced call is rejected with NotAuthorizedError (not NotFoundError) and writes nothing — proves the batched authorization preserves the same per-item outcome as the single-event path", async () => {
+    const owner = await newOwner("u4bulkViewOwner");
+    const viewer = await newOwner("u4bulkViewViewer");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: viewer,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "view",
+    });
+
+    await expect(
+      logServiceEventsBulk(viewer, {
+        items: [
+          { parentType: "firearm", parentId: fa.id, ruleName: "Cleaning" },
+        ],
+        servicedOn: "2026-04-02",
+      }),
+    ).rejects.toBeInstanceOf(NotAuthorizedError);
+
+    const rows = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa.id));
+    expect(rows).toHaveLength(0);
+  });
+
+  test("an edit-grantee's bulk mark-serviced call across shared firearms succeeds, matching what the single-event path already allows them", async () => {
+    const owner = await newOwner("u4bulkEditOwner");
+    const editor = await newOwner("u4bulkEditor");
+    const fa1 = await makeFirearm(owner, { type: "rifle" });
+    const fa2 = await makeFirearm(owner, { type: "pistol" });
+    await armCleaningRule(owner, "firearm", fa1.id);
+    await armCleaningRule(owner, "firearm", fa2.id);
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: editor,
+      parentType: "firearm",
+      parentId: fa1.id,
+      permission: "edit",
+    });
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: editor,
+      parentType: "firearm",
+      parentId: fa2.id,
+      permission: "edit",
+    });
+
+    const events = await logServiceEventsBulk(editor, {
+      items: [
+        { parentType: "firearm", parentId: fa1.id, ruleName: "Cleaning" },
+        { parentType: "firearm", parentId: fa2.id, ruleName: "Cleaning" },
+      ],
+      servicedOn: "2026-04-03",
+    });
+
+    expect(events).toHaveLength(2);
+    for (const event of events) expect(event.actorId).toBe(editor);
+  });
+
+  test("an edit-grantee's bulk mark-serviced call rejects when it includes an accessory they don't own, even though they can edit the firearm it's mounted to, and writes nothing", async () => {
+    const owner = await newOwner("u4bulkAccSplitOwner");
+    const editor = await newOwner("u4bulkAccSplitEditor");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const acc = await makeAccessory(owner, { currentFirearmId: fa.id });
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: editor,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "edit",
+    });
+
+    await expect(
+      logServiceEventsBulk(editor, {
+        items: [
+          { parentType: "firearm", parentId: fa.id, ruleName: "Cleaning" },
+          { parentType: "accessory", parentId: acc.id, ruleName: "Cleaning" },
+        ],
+        servicedOn: "2026-04-03",
+      }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+
+    const rows = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa.id));
+    expect(rows).toHaveLength(0);
+  });
+
+  test("an empty bulk items list writes nothing and returns an empty array", async () => {
+    const owner = await newOwner("u4bulkEmptyOwner");
+    const events = await logServiceEventsBulk(owner, {
+      items: [],
+      servicedOn: "2026-04-04",
+    });
+    expect(events).toEqual([]);
+  });
+
+  test("service history returns events newest first and names the rule each serviced", async () => {
+    const owner = await newOwner("u4historyOwner");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await createItemRule(owner, "firearm", fa.id, {
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    await createItemRule(owner, "firearm", fa.id, {
+      name: "Barrel",
+      intervalRounds: 5000,
+    });
+    await createItemRule(owner, "firearm", fa.id, {
+      name: "Lubrication",
+      intervalRounds: 250,
+    });
+
+    await logServiceEvent(owner, "firearm", fa.id, {
+      ruleName: "Cleaning",
+      servicedOn: "2026-01-01",
+    });
+    await logServiceEvent(owner, "firearm", fa.id, {
+      ruleName: "Barrel",
+      servicedOn: "2026-03-01",
+    });
+    await logServiceEvent(owner, "firearm", fa.id, {
+      ruleName: "Lubrication",
+      servicedOn: "2026-02-01",
+    });
+
+    const history = await listServiceHistory(owner, "firearm", fa.id);
+    expect(history.map((e) => e.ruleName)).toEqual([
+      "Barrel",
+      "Lubrication",
+      "Cleaning",
+    ]);
+  });
+
+  test("a view-grantee can read a shared firearm's service history", async () => {
+    const owner = await newOwner("u4historyViewOwner");
+    const viewer = await newOwner("u4historyViewer");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await armCleaningRule(owner, "firearm", fa.id);
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: viewer,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "view",
+    });
+    await logServiceEvent(owner, "firearm", fa.id, {
+      ruleName: "Cleaning",
+      servicedOn: "2026-01-01",
+    });
+
+    const history = await listServiceHistory(viewer, "firearm", fa.id);
+    expect(history).toHaveLength(1);
+  });
+
+  test("a firearm's view-grantee cannot read an accessory's service history, even when mounted on the shared firearm", async () => {
+    const owner = await newOwner("u4historyAccOwner");
+    const viewer = await newOwner("u4historyAccViewer");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const acc = await makeAccessory(owner, { currentFirearmId: fa.id });
+    await armCleaningRule(owner, "accessory", acc.id);
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: viewer,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "view",
+    });
+    await logServiceEvent(owner, "accessory", acc.id, {
+      ruleName: "Cleaning",
+      servicedOn: "2026-01-01",
+    });
+
+    await expect(
+      listServiceHistory(viewer, "accessory", acc.id),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  // ---- F2: a stale (renamed-away) rule name is rejected, not written ----
+
+  describe("F2: ruleName must resolve against the item's current effective rule set", () => {
+    test("logServiceEvent rejects a rule name renamed away since it was captured, and writes nothing", async () => {
+      const owner = await newOwner("u4f2Owner");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      const rule = await createItemRule(owner, "firearm", fa.id, {
+        name: "Cleaning",
+        intervalRounds: 500,
+      });
+      await updateItemRule(owner, "firearm", fa.id, rule.id, {
+        name: "Deep Clean",
+        intervalRounds: 500,
+      });
+
+      await expect(
+        logServiceEvent(owner, "firearm", fa.id, {
+          ruleName: "Cleaning",
+          servicedOn: "2026-01-01",
+        }),
+      ).rejects.toBeInstanceOf(ValidationError);
+
+      const rows = await db
+        .select()
+        .from(serviceEvent)
+        .where(eq(serviceEvent.firearmId, fa.id));
+      expect(rows).toHaveLength(0);
+    });
+
+    test("logServiceEventsBulk rejects a rule name renamed away since it was captured, and writes nothing", async () => {
+      const owner = await newOwner("u4f2BulkOwner");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      const rule = await createItemRule(owner, "firearm", fa.id, {
+        name: "Cleaning",
+        intervalRounds: 500,
+      });
+      await updateItemRule(owner, "firearm", fa.id, rule.id, {
+        name: "Deep Clean",
+        intervalRounds: 500,
+      });
+
+      await expect(
+        logServiceEventsBulk(owner, {
+          items: [
+            { parentType: "firearm", parentId: fa.id, ruleName: "Cleaning" },
+          ],
+          servicedOn: "2026-01-02",
+        }),
+      ).rejects.toBeInstanceOf(ValidationError);
+
+      const rows = await db
+        .select()
+        .from(serviceEvent)
+        .where(eq(serviceEvent.firearmId, fa.id));
+      expect(rows).toHaveLength(0);
+    });
+  });
+
+  // ---- F6: the bulk batch-size cap ----
+
+  describe("F6: logServiceEventsBulk bounds batch size", () => {
+    test(`a batch of exactly MAX_BULK_SERVICE_ITEMS (${MAX_BULK_SERVICE_ITEMS}) succeeds`, async () => {
+      const owner = await newOwner("u4f6AtCapOwner");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await armCleaningRule(owner, "firearm", fa.id);
+
+      const items: BulkServiceItem[] = Array.from(
+        { length: MAX_BULK_SERVICE_ITEMS },
+        () => ({
+          parentType: "firearm",
+          parentId: fa.id,
+          ruleName: "Cleaning",
+        }),
+      );
+
+      const events = await logServiceEventsBulk(owner, {
+        items,
+        servicedOn: "2026-01-03",
+      });
+      expect(events).toHaveLength(MAX_BULK_SERVICE_ITEMS);
+    });
+
+    test(`a batch one over MAX_BULK_SERVICE_ITEMS (${MAX_BULK_SERVICE_ITEMS + 1}) is rejected before any write`, async () => {
+      const owner = await newOwner("u4f6OverCapOwner");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await armCleaningRule(owner, "firearm", fa.id);
+
+      const items: BulkServiceItem[] = Array.from(
+        { length: MAX_BULK_SERVICE_ITEMS + 1 },
+        () => ({
+          parentType: "firearm",
+          parentId: fa.id,
+          ruleName: "Cleaning",
+        }),
+      );
+
+      await expect(
+        logServiceEventsBulk(owner, { items, servicedOn: "2026-01-04" }),
+      ).rejects.toBeInstanceOf(ValidationError);
+
+      const rows = await db
+        .select()
+        .from(serviceEvent)
+        .where(eq(serviceEvent.firearmId, fa.id));
+      expect(rows).toHaveLength(0);
+    });
+  });
+
+  // ---- F8: duplicate item+rule pairs in one bulk call ----
+
+  test("F8: duplicate item+rule pairs in one bulk call each write their own event (no dedup)", async () => {
+    const owner = await newOwner("u4f8DupOwner");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await armCleaningRule(owner, "firearm", fa.id);
+
+    const events = await logServiceEventsBulk(owner, {
+      items: [
+        { parentType: "firearm", parentId: fa.id, ruleName: "Cleaning" },
+        { parentType: "firearm", parentId: fa.id, ruleName: "Cleaning" },
+      ],
+      servicedOn: "2026-01-05",
+    });
+
+    expect(events).toHaveLength(2);
+    const rows = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa.id));
+    expect(rows).toHaveLength(2);
+  });
+
+  // ---- correction path: updateServiceEvent / deleteServiceEvent ----
+  //
+  // U4 originally shipped only logServiceEvent/logServiceEventsBulk/
+  // listServiceHistory — a mis-logged event had no in-app fix. These two
+  // functions close that gap. Date fixtures below are ISO strings compared
+  // against an explicit, pinned `asOf` (KTD5's local-frame convention,
+  // mirroring `due-service.test.ts`'s `localDate` helper) so due-state
+  // assertions never depend on the moment the suite happens to run.
+
+  describe("correction path: updateServiceEvent / deleteServiceEvent", () => {
+    test("resolveServiceEventParent resolves a firearm-parented row and an accessory-parented row", () => {
+      expect(
+        resolveServiceEventParent({ firearmId: "fa-1", accessoryId: null }),
+      ).toEqual({ parentType: "firearm", parentId: "fa-1" });
+      expect(
+        resolveServiceEventParent({ firearmId: null, accessoryId: "acc-1" }),
+      ).toEqual({ parentType: "accessory", parentId: "acc-1" });
+    });
+
+    // The DB's exactly-one-parent CHECK (KTD2) forbids a real row from ever
+    // having both FKs null, but `resolveServiceEventParent` now routes
+    // through the shared `resolveParent` helper (rules-service.ts) for that
+    // resolution — this pins the defensive fallback's behavior in the one
+    // place it's exercisable at all: a plain object literal, not a real row.
+    test("resolveServiceEventParent throws NotFoundError for a row with neither parent set", () => {
+      expect(() =>
+        resolveServiceEventParent({ firearmId: null, accessoryId: null }),
+      ).toThrow(NotFoundError);
+    });
+
+    test("editing an event's date changes that rule's due state; editing only notes does not", async () => {
+      const owner = await newOwner("u4corrDateOwner");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await createItemRule(owner, "firearm", fa.id, {
+        name: "Cleaning",
+        intervalDays: 10,
+      });
+      const asOf = localDate(2026, 5, 30); // 2026-06-30
+
+      const event = await logServiceEvent(owner, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-06-25", // 5 days before asOf — not due (threshold 10)
+      });
+
+      const before = await getItemDueState(owner, "firearm", fa.id, asOf);
+      expect(before.find((r) => r.name === "Cleaning")?.due).toBe(false);
+
+      const corrected = await updateServiceEvent(owner, event.id, {
+        servicedOn: "2026-06-01", // 29 days before asOf — now past the threshold
+      });
+      expect(corrected).toMatchObject({
+        id: event.id,
+        ruleName: "Cleaning",
+        servicedOn: "2026-06-01",
+      });
+
+      const afterDateEdit = await getItemDueState(
+        owner,
+        "firearm",
+        fa.id,
+        asOf,
+      );
+      const cleaningAfterDate = afterDateEdit.find(
+        (r) => r.name === "Cleaning",
+      );
+      expect(cleaningAfterDate?.due).toBe(true);
+      expect(cleaningAfterDate?.counts.days).toBe(29);
+
+      // Editing ONLY notes must not move the measure-from date or due state.
+      await updateServiceEvent(owner, event.id, {
+        servicedOn: "2026-06-01",
+        notes: "corrected note",
+      });
+      const afterNotesEdit = await getItemDueState(
+        owner,
+        "firearm",
+        fa.id,
+        asOf,
+      );
+      const cleaningAfterNotes = afterNotesEdit.find(
+        (r) => r.name === "Cleaning",
+      );
+      expect(cleaningAfterNotes?.due).toBe(true);
+      expect(cleaningAfterNotes?.counts.days).toBe(29);
+
+      const history = await listServiceHistory(owner, "firearm", fa.id);
+      expect(history).toHaveLength(1);
+      expect(history[0]).toMatchObject({
+        servicedOn: "2026-06-01",
+        notes: "corrected note",
+      });
+    });
+
+    test("updateServiceEvent ignores any ruleName smuggled onto the input — an event's rule never changes via edit", async () => {
+      const owner = await newOwner("u4corrRuleImmutableOwner");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await createItemRule(owner, "firearm", fa.id, {
+        name: "Cleaning",
+        intervalDays: 10,
+      });
+      await createItemRule(owner, "firearm", fa.id, {
+        name: "Barrel",
+        intervalDays: 10,
+      });
+      const event = await logServiceEvent(owner, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+      });
+
+      // `ServiceEventUpdateInput` has no `ruleName` field at all — this cast
+      // simulates a caller that bypasses the type system, proving the
+      // constraint holds at runtime too, not just at compile time.
+      const sneaky = {
+        servicedOn: "2026-01-02",
+        ruleName: "Barrel",
+      } as unknown as ServiceEventUpdateInput;
+
+      const updated = await updateServiceEvent(owner, event.id, sneaky);
+      expect(updated.ruleName).toBe("Cleaning");
+    });
+
+    test("deleting the newest event for a rule falls back to the previous event", async () => {
+      const owner = await newOwner("u4corrFallbackPrevOwner");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await createItemRule(owner, "firearm", fa.id, {
+        name: "Cleaning",
+        intervalDays: 10,
+      });
+      const asOf = localDate(2026, 5, 30); // 2026-06-30
+
+      const older = await makeServiceEvent(
+        { firearmId: fa.id },
+        { ruleName: "Cleaning", servicedOn: "2026-06-01", actorId: owner },
+      );
+      const newest = await logServiceEvent(owner, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-06-25",
+      });
+
+      // Before deletion: measures from the NEWEST event (June 25) — not due.
+      const before = await getItemDueState(owner, "firearm", fa.id, asOf);
+      expect(before.find((r) => r.name === "Cleaning")?.due).toBe(false);
+
+      const deleted = await deleteServiceEvent(owner, newest.id);
+      expect(deleted.id).toBe(newest.id);
+
+      // After deletion: falls back to the PREVIOUS event (June 1) — due.
+      const after = await getItemDueState(owner, "firearm", fa.id, asOf);
+      const cleaningAfter = after.find((r) => r.name === "Cleaning");
+      expect(cleaningAfter?.due).toBe(true);
+      expect(cleaningAfter?.counts.days).toBe(29);
+
+      const history = await listServiceHistory(owner, "firearm", fa.id);
+      expect(history).toHaveLength(1);
+      expect(history[0].id).toBe(older.id);
+    });
+
+    test("deleting the only event for a rule falls back to the item's origin date", async () => {
+      const owner = await newOwner("u4corrFallbackOriginOwner");
+      const fa = await makeFirearm(owner, {
+        type: "rifle",
+        acquiredDate: "2026-01-01",
+      });
+      await createItemRule(owner, "firearm", fa.id, {
+        name: "Cleaning",
+        intervalDays: 10,
+      });
+      const asOf = localDate(2026, 5, 30); // 2026-06-30
+
+      const onlyEvent = await logServiceEvent(owner, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-06-25",
+      });
+
+      const before = await getItemDueState(owner, "firearm", fa.id, asOf);
+      expect(before.find((r) => r.name === "Cleaning")?.due).toBe(false);
+
+      await deleteServiceEvent(owner, onlyEvent.id);
+
+      // No service event remains — falls back to the firearm's acquired date
+      // (2026-01-01), 180 days before asOf, well past the 10-day threshold.
+      const after = await getItemDueState(owner, "firearm", fa.id, asOf);
+      const cleaningAfter = after.find((r) => r.name === "Cleaning");
+      expect(cleaningAfter?.due).toBe(true);
+      expect(cleaningAfter?.counts.days).toBe(180);
+
+      const history = await listServiceHistory(owner, "firearm", fa.id);
+      expect(history).toHaveLength(0);
+    });
+
+    test("an edit-grantee can edit and delete a service event on a shared firearm", async () => {
+      const owner = await newOwner("u4corrEditGranteeOwner");
+      const editor = await newOwner("u4corrEditGranteeEditor");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await armCleaningRule(owner, "firearm", fa.id);
+      await createGrant(db, {
+        actorId: owner,
+        granteeId: editor,
+        parentType: "firearm",
+        parentId: fa.id,
+        permission: "edit",
+      });
+      const event = await logServiceEvent(owner, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+      });
+
+      const updated = await updateServiceEvent(editor, event.id, {
+        servicedOn: "2026-01-02",
+        notes: "edited by grantee",
+      });
+      expect(updated.servicedOn).toBe("2026-01-02");
+
+      await deleteServiceEvent(editor, event.id);
+      const rows = await db
+        .select()
+        .from(serviceEvent)
+        .where(eq(serviceEvent.id, event.id));
+      expect(rows).toHaveLength(0);
+    });
+
+    test("a view-grantee cannot edit or delete a service event on a shared firearm", async () => {
+      const owner = await newOwner("u4corrViewGranteeOwner");
+      const viewer = await newOwner("u4corrViewGranteeViewer");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await armCleaningRule(owner, "firearm", fa.id);
+      await createGrant(db, {
+        actorId: owner,
+        granteeId: viewer,
+        parentType: "firearm",
+        parentId: fa.id,
+        permission: "view",
+      });
+      const event = await logServiceEvent(owner, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+      });
+
+      await expect(
+        updateServiceEvent(viewer, event.id, { servicedOn: "2026-01-02" }),
+      ).rejects.toBeInstanceOf(NotAuthorizedError);
+      await expect(deleteServiceEvent(viewer, event.id)).rejects.toBeInstanceOf(
+        NotAuthorizedError,
+      );
+
+      const rows = await db
+        .select()
+        .from(serviceEvent)
+        .where(eq(serviceEvent.id, event.id));
+      expect(rows).toHaveLength(1);
+      expect(rows[0].servicedOn).toBe("2026-01-01");
+    });
+
+    test("a non-owner cannot edit or delete a service event on an accessory even when they can see the firearm it is mounted to", async () => {
+      const owner = await newOwner("u4corrAccOwner");
+      const viewer = await newOwner("u4corrAccViewer");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      const acc = await makeAccessory(owner, { currentFirearmId: fa.id });
+      await armCleaningRule(owner, "accessory", acc.id);
+      await createGrant(db, {
+        actorId: owner,
+        granteeId: viewer,
+        parentType: "firearm",
+        parentId: fa.id,
+        permission: "edit",
+      });
+      const event = await logServiceEvent(owner, "accessory", acc.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+      });
+
+      await expect(
+        updateServiceEvent(viewer, event.id, { servicedOn: "2026-01-02" }),
+      ).rejects.toBeInstanceOf(NotFoundError);
+      await expect(deleteServiceEvent(viewer, event.id)).rejects.toBeInstanceOf(
+        NotFoundError,
+      );
+
+      const rows = await db
+        .select()
+        .from(serviceEvent)
+        .where(eq(serviceEvent.id, event.id));
+      expect(rows).toHaveLength(1);
+    });
+
+    test("editing or deleting an event the actor cannot see at all raises NotFoundError", async () => {
+      const owner = await newOwner("u4corrStrangerOwner");
+      const stranger = await newOwner("u4corrStranger");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await armCleaningRule(owner, "firearm", fa.id);
+      const event = await logServiceEvent(owner, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+      });
+
+      await expect(
+        updateServiceEvent(stranger, event.id, { servicedOn: "2026-01-02" }),
+      ).rejects.toBeInstanceOf(NotFoundError);
+      await expect(
+        deleteServiceEvent(stranger, event.id),
+      ).rejects.toBeInstanceOf(NotFoundError);
+
+      const rows = await db
+        .select()
+        .from(serviceEvent)
+        .where(eq(serviceEvent.id, event.id));
+      expect(rows).toHaveLength(1);
+    });
+
+    test("updating or deleting a nonexistent event id raises NotFoundError", async () => {
+      const owner = await newOwner("u4corrMissingOwner");
+      const missingId = "00000000-0000-0000-0000-000000000000";
+
+      await expect(
+        updateServiceEvent(owner, missingId, { servicedOn: "2026-01-02" }),
+      ).rejects.toBeInstanceOf(NotFoundError);
+      await expect(deleteServiceEvent(owner, missingId)).rejects.toBeInstanceOf(
+        NotFoundError,
+      );
+    });
+
+    test("editing to a servicedOn more than one day in the future throws ValidationError and writes no change", async () => {
+      const owner = await newOwner("u4corrFutureOwner");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await armCleaningRule(owner, "firearm", fa.id);
+      const event = await logServiceEvent(owner, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+      });
+
+      await expect(
+        updateServiceEvent(owner, event.id, {
+          servicedOn: isoDateOffset(2),
+        }),
+      ).rejects.toMatchObject({ codes: ["servicedOnInFuture"] });
+
+      const rows = await db
+        .select()
+        .from(serviceEvent)
+        .where(eq(serviceEvent.id, event.id));
+      expect(rows[0].servicedOn).toBe("2026-01-01");
+    });
+
+    test("editing to a servicedOn exactly one day in the future is accepted (same one-day tolerance as logging)", async () => {
+      const owner = await newOwner("u4corrTomorrowOwner");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await armCleaningRule(owner, "firearm", fa.id);
+      const event = await logServiceEvent(owner, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-01-01",
+      });
+      const tomorrow = isoDateOffset(1);
+
+      const updated = await updateServiceEvent(owner, event.id, {
+        servicedOn: tomorrow,
+      });
+      expect(updated.servicedOn).toBe(tomorrow);
+    });
+  });
+
+  /**
+   * `authorizeEventWritesBatch` (the bulk path's authorization) reimplements
+   * firearm authorization inline using `visibleFirearmPermissions`, rather
+   * than calling `authorizeEventWrite`/`authorizeUpdate` (the single path's
+   * gate) in a loop. The doc comments above both functions claim the two
+   * produce identical outcomes; these tests pin that claim down directly by
+   * calling BOTH `logServiceEvent` and `logServiceEventsBulk` against the
+   * SAME firearm with the SAME actor at each permission tier, so a future
+   * change that loosens one path without the other fails a test instead of
+   * silently drifting.
+   */
+  describe("authorization parity: logServiceEvent vs logServiceEventsBulk (same actor, same firearm)", () => {
+    test("the owner succeeds identically via both paths", async () => {
+      const owner = await newOwner("u4parityOwner");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await armCleaningRule(owner, "firearm", fa.id);
+
+      const single = await logServiceEvent(owner, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-05-01",
+      });
+      const [bulk] = await logServiceEventsBulk(owner, {
+        items: [
+          { parentType: "firearm", parentId: fa.id, ruleName: "Cleaning" },
+        ],
+        servicedOn: "2026-05-02",
+      });
+
+      expect(single.actorId).toBe(owner);
+      expect(bulk.actorId).toBe(owner);
+    });
+
+    test("an edit-grantee succeeds identically via both paths", async () => {
+      const owner = await newOwner("u4parityEditOwner");
+      const editor = await newOwner("u4parityEditor");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await armCleaningRule(owner, "firearm", fa.id);
+      await createGrant(db, {
+        actorId: owner,
+        granteeId: editor,
+        parentType: "firearm",
+        parentId: fa.id,
+        permission: "edit",
+      });
+
+      const single = await logServiceEvent(editor, "firearm", fa.id, {
+        ruleName: "Cleaning",
+        servicedOn: "2026-05-01",
+      });
+      const [bulk] = await logServiceEventsBulk(editor, {
+        items: [
+          { parentType: "firearm", parentId: fa.id, ruleName: "Cleaning" },
+        ],
+        servicedOn: "2026-05-02",
+      });
+
+      expect(single.actorId).toBe(editor);
+      expect(bulk.actorId).toBe(editor);
+    });
+
+    test("a view-grantee is rejected identically (NotAuthorizedError) via both paths", async () => {
+      const owner = await newOwner("u4parityViewOwner");
+      const viewer = await newOwner("u4parityViewer");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+      await createGrant(db, {
+        actorId: owner,
+        granteeId: viewer,
+        parentType: "firearm",
+        parentId: fa.id,
+        permission: "view",
+      });
+
+      await expect(
+        logServiceEvent(viewer, "firearm", fa.id, {
+          ruleName: "Cleaning",
+          servicedOn: "2026-05-01",
+        }),
+      ).rejects.toBeInstanceOf(NotAuthorizedError);
+      await expect(
+        logServiceEventsBulk(viewer, {
+          items: [
+            { parentType: "firearm", parentId: fa.id, ruleName: "Cleaning" },
+          ],
+          servicedOn: "2026-05-01",
+        }),
+      ).rejects.toBeInstanceOf(NotAuthorizedError);
+    });
+
+    test("a stranger with no grant at all is rejected identically (NotFoundError) via both paths", async () => {
+      const owner = await newOwner("u4parityStrangerOwner");
+      const stranger = await newOwner("u4parityStranger");
+      const fa = await makeFirearm(owner, { type: "rifle" });
+
+      await expect(
+        logServiceEvent(stranger, "firearm", fa.id, {
+          ruleName: "Cleaning",
+          servicedOn: "2026-05-01",
+        }),
+      ).rejects.toBeInstanceOf(NotFoundError);
+      await expect(
+        logServiceEventsBulk(stranger, {
+          items: [
+            { parentType: "firearm", parentId: fa.id, ruleName: "Cleaning" },
+          ],
+          servicedOn: "2026-05-01",
+        }),
+      ).rejects.toBeInstanceOf(NotFoundError);
+    });
+  });
+});
diff --git a/src/domain/service-intervals/__tests__/rules-service.test.ts b/src/domain/service-intervals/__tests__/rules-service.test.ts
new file mode 100644
index 00000000..621b5f70
--- /dev/null
+++ b/src/domain/service-intervals/__tests__/rules-service.test.ts
@@ -0,0 +1,861 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { eq } from "drizzle-orm";
+import { NotAuthorizedError, NotFoundError } from "@/src/auth/errors";
+import { createGrant } from "@/src/auth/grants";
+import { db } from "@/src/db/client";
+import { serviceEvent } from "@/src/db/schema";
+import { ValidationError } from "@/src/domain/errors";
+import {
+  createUser,
+  deleteUsers,
+  makeAccessory,
+  makeFirearm,
+  makeServiceEvent,
+} from "@/src/test-support/factories";
+import { getItemDueState } from "../due-service";
+import {
+  countItemsInCategory,
+  createItemRule,
+  createServiceRuleDefault,
+  deleteItemRule,
+  deleteServiceRuleDefault,
+  listConfiguredCategories,
+  listItemRules,
+  listOwnerAccessoryCategories,
+  listServiceRuleDefaults,
+  resolveParent,
+  updateItemRule,
+  updateServiceRuleDefault,
+} from "../rules-service";
+
+/**
+ * `resolveParent` is the shared, pure implementation behind three call sites
+ * that used to each re-derive "which parent does this row belong to"
+ * independently (`belongsToParent` here, `resolveServiceEventParent` in
+ * `events-service.ts`, and `loadItemRulesBatch`'s per-row extraction in
+ * `due-service.ts`) — no DB needed, unlike the rest of this file's
+ * Testcontainers-backed suite.
+ */
+describe("resolveParent", () => {
+  test("resolves a firearm-parented row", () => {
+    expect(resolveParent({ firearmId: "fa-1", accessoryId: null })).toEqual({
+      parentType: "firearm",
+      parentId: "fa-1",
+    });
+  });
+
+  test("resolves an accessory-parented row", () => {
+    expect(resolveParent({ firearmId: null, accessoryId: "acc-1" })).toEqual({
+      parentType: "accessory",
+      parentId: "acc-1",
+    });
+  });
+
+  test("returns null for a row with neither parent set (the exactly-one-parent CHECK forbids this for a real row)", () => {
+    expect(resolveParent({ firearmId: null, accessoryId: null })).toBeNull();
+  });
+});
+
+/**
+ * Rules-service integration tests (service-intervals plan, U3). Each test
+ * creates its own owner(s) rather than sharing state with other tests, since
+ * defaults are keyed on (owner, scope, category, name) and several tests
+ * deliberately reuse the same category/name to prove owner-scoping — sharing
+ * a fixture owner across tests would collide on that unique constraint.
+ */
+describe("service-intervals rules-service (U3)", () => {
+  const createdUsers: string[] = [];
+
+  afterAll(async () => {
+    await deleteUsers(...createdUsers);
+  });
+
+  async function newOwner(label: string): Promise<string> {
+    const id = await createUser(label);
+    createdUsers.push(id);
+    return id;
+  }
+
+  test("covers AE1: raising a default after an override leaves the override untouched and reaches every other rifle", async () => {
+    const owner = await newOwner("u3ae1");
+    const ar15 = await makeFirearm(owner, { type: "rifle" });
+    const otherRifle = await makeFirearm(owner, { type: "rifle" });
+
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    const barrelDefault = await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Barrel",
+      intervalRounds: 5000,
+    });
+
+    await createItemRule(owner, "firearm", ar15.id, {
+      name: "Barrel",
+      intervalRounds: 4000,
+    });
+
+    await updateServiceRuleDefault(owner, barrelDefault.id, {
+      name: "Barrel",
+      intervalRounds: 6000,
+    });
+
+    const ar15Rules = await getItemDueState(owner, "firearm", ar15.id);
+    const otherRules = await getItemDueState(owner, "firearm", otherRifle.id);
+
+    expect(ar15Rules.find((r) => r.name === "Barrel")).toMatchObject({
+      intervalRounds: 4000,
+      inheritanceState: "overridden",
+    });
+    expect(ar15Rules.find((r) => r.name === "Cleaning")).toMatchObject({
+      intervalRounds: 500,
+      inheritanceState: "inherited",
+    });
+    expect(otherRules.find((r) => r.name === "Barrel")).toMatchObject({
+      intervalRounds: 6000,
+      inheritanceState: "inherited",
+    });
+  });
+
+  test("covers R5: deleting an override restores the inherited default; deleting a suppression restores the rule", async () => {
+    const owner = await newOwner("u3r5");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+
+    const override = await createItemRule(owner, "firearm", fa.id, {
+      name: "Cleaning",
+      intervalRounds: 300,
+    });
+    let resolved = await getItemDueState(owner, "firearm", fa.id);
+    expect(resolved.find((r) => r.name === "Cleaning")).toMatchObject({
+      intervalRounds: 300,
+      inheritanceState: "overridden",
+    });
+
+    await deleteItemRule(owner, "firearm", fa.id, override.id);
+    resolved = await getItemDueState(owner, "firearm", fa.id);
+    expect(resolved.find((r) => r.name === "Cleaning")).toMatchObject({
+      intervalRounds: 500,
+      inheritanceState: "inherited",
+    });
+
+    const suppression = await createItemRule(owner, "firearm", fa.id, {
+      name: "Cleaning",
+      suppressed: true,
+    });
+    resolved = await getItemDueState(owner, "firearm", fa.id);
+    expect(resolved.find((r) => r.name === "Cleaning")).toBeUndefined();
+
+    await deleteItemRule(owner, "firearm", fa.id, suppression.id);
+    resolved = await getItemDueState(owner, "firearm", fa.id);
+    expect(resolved.find((r) => r.name === "Cleaning")).toMatchObject({
+      intervalRounds: 500,
+      inheritanceState: "inherited",
+    });
+  });
+
+  test("suppressing a rule stores a suppressed row rather than deleting the default", async () => {
+    const owner = await newOwner("u3suppress");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const def = await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+
+    await createItemRule(owner, "firearm", fa.id, {
+      name: "Cleaning",
+      suppressed: true,
+    });
+
+    const rules = await listItemRules(owner, "firearm", fa.id);
+    expect(rules).toHaveLength(1);
+    expect(rules[0]).toMatchObject({
+      name: "Cleaning",
+      suppressed: true,
+      intervalDays: null,
+      intervalSessions: null,
+      intervalRounds: null,
+    });
+
+    const stillDefaults = await listServiceRuleDefaults(
+      owner,
+      "firearm",
+      "rifle",
+    );
+    expect(stillDefaults.map((d) => d.id)).toContain(def.id);
+  });
+
+  test("a default set defined for one owner is invisible to another owner with an identically-named category", async () => {
+    const ownerA = await newOwner("u3defA");
+    const ownerB = await newOwner("u3defB");
+    await createServiceRuleDefault(ownerA, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+
+    const bDefaults = await listServiceRuleDefaults(ownerB, "firearm", "rifle");
+    expect(bDefaults).toHaveLength(0);
+  });
+
+  test("an edit-grantee attempting to create, edit, or delete an item rule on a shared firearm is rejected", async () => {
+    const owner = await newOwner("u3editOwner");
+    const editor = await newOwner("u3editor");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: editor,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "edit",
+    });
+
+    await expect(
+      createItemRule(editor, "firearm", fa.id, {
+        name: "Cleaning",
+        intervalRounds: 500,
+      }),
+    ).rejects.toBeInstanceOf(NotAuthorizedError);
+
+    const rule = await createItemRule(owner, "firearm", fa.id, {
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+
+    await expect(
+      updateItemRule(editor, "firearm", fa.id, rule.id, {
+        name: "Cleaning",
+        intervalRounds: 600,
+      }),
+    ).rejects.toBeInstanceOf(NotAuthorizedError);
+
+    await expect(
+      deleteItemRule(editor, "firearm", fa.id, rule.id),
+    ).rejects.toBeInstanceOf(NotAuthorizedError);
+  });
+
+  test("a view-grantee reading a shared firearm's rules receives the owner's resolved rules, not their own defaults", async () => {
+    const owner = await newOwner("u3viewOwner");
+    const viewer = await newOwner("u3viewer");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: viewer,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "view",
+    });
+
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    // The viewer's OWN identically-named category default must never leak in.
+    await createServiceRuleDefault(viewer, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 999,
+    });
+
+    const resolved = await getItemDueState(viewer, "firearm", fa.id);
+    expect(resolved.find((r) => r.name === "Cleaning")).toMatchObject({
+      intervalRounds: 500,
+      inheritanceState: "inherited",
+    });
+  });
+
+  test("a user with no visibility on a firearm receives NotFoundError rather than a permission error when reading its rules", async () => {
+    const owner = await newOwner("u3noVisOwner");
+    const stranger = await newOwner("u3noVisStranger");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+
+    await expect(
+      getItemDueState(stranger, "firearm", fa.id),
+    ).rejects.toBeInstanceOf(NotFoundError);
+    await expect(
+      listItemRules(stranger, "firearm", fa.id),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  test("renaming an item rule carries that item's service events to the new name and leaves an identically-named rule on a different item alone", async () => {
+    const owner = await newOwner("u3renameOwner");
+    const fa1 = await makeFirearm(owner, { type: "rifle" });
+    const fa2 = await makeFirearm(owner, { type: "rifle" });
+
+    const rule1 = await createItemRule(owner, "firearm", fa1.id, {
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    await createItemRule(owner, "firearm", fa2.id, {
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+
+    await makeServiceEvent(
+      { firearmId: fa1.id },
+      { ruleName: "Cleaning", servicedOn: "2026-01-01" },
+    );
+    await makeServiceEvent(
+      { firearmId: fa2.id },
+      { ruleName: "Cleaning", servicedOn: "2026-01-02" },
+    );
+
+    await updateItemRule(owner, "firearm", fa1.id, rule1.id, {
+      name: "Deep Clean",
+      intervalRounds: 500,
+    });
+
+    const fa1Events = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa1.id));
+    expect(fa1Events.map((e) => e.ruleName)).toEqual(["Deep Clean"]);
+
+    const fa2Events = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa2.id));
+    expect(fa2Events.map((e) => e.ruleName)).toEqual(["Cleaning"]);
+
+    const fa2Rules = await listItemRules(owner, "firearm", fa2.id);
+    expect(fa2Rules.map((r) => r.name)).toEqual(["Cleaning"]);
+  });
+
+  test("renaming an item rule onto a name that item already carries throws ValidationError and leaves both rules and their events unchanged", async () => {
+    const owner = await newOwner("u3renameDupOwner");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const cleaning = await createItemRule(owner, "firearm", fa.id, {
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    const barrel = await createItemRule(owner, "firearm", fa.id, {
+      name: "Barrel",
+      intervalRounds: 5000,
+    });
+    await makeServiceEvent(
+      { firearmId: fa.id },
+      { ruleName: "Cleaning", servicedOn: "2026-01-01" },
+    );
+    await makeServiceEvent(
+      { firearmId: fa.id },
+      { ruleName: "Barrel", servicedOn: "2026-01-02" },
+    );
+
+    await expect(
+      updateItemRule(owner, "firearm", fa.id, barrel.id, {
+        name: "Cleaning",
+        intervalRounds: 6000,
+      }),
+    ).rejects.toBeInstanceOf(ValidationError);
+
+    const rules = await listItemRules(owner, "firearm", fa.id);
+    expect(rules.find((r) => r.id === barrel.id)).toMatchObject({
+      name: "Barrel",
+      intervalRounds: 5000,
+    });
+    expect(rules.find((r) => r.id === cleaning.id)).toMatchObject({
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+
+    const events = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa.id));
+    expect(events.map((e) => e.ruleName).sort()).toEqual([
+      "Barrel",
+      "Cleaning",
+    ]);
+  });
+
+  // PR #99 review (P2): renaming a category default silently stranded the
+  // service history of every item inheriting or overriding it, since
+  // everything is keyed by rule NAME (KTD1) — the same bug class already
+  // fixed above for an item-rule rename, applied one level up.
+  test("renaming a default carries an inheriting item's service history to the new name and it still measures from the last service event, not the origin", async () => {
+    const owner = await newOwner("u3defRenameInherit");
+    const fa = await makeFirearm(owner, {
+      type: "rifle",
+      acquiredDate: "2020-01-01",
+    });
+    const def = await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalDays: 30,
+    });
+    await makeServiceEvent(
+      { firearmId: fa.id },
+      { ruleName: "Cleaning", servicedOn: "2026-01-01" },
+    );
+
+    await updateServiceRuleDefault(owner, def.id, {
+      name: "Deep Clean",
+      intervalDays: 30,
+    });
+
+    const events = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa.id));
+    expect(events.map((e) => e.ruleName)).toEqual(["Deep Clean"]);
+
+    const resolved = await getItemDueState(owner, "firearm", fa.id);
+    const rule = resolved.find((r) => r.name === "Deep Clean");
+    expect(rule).toMatchObject({ inheritanceState: "inherited" });
+    // Measuring from the last service event (2026-01-01), never the item's
+    // 2020 origin date — the rename must not reset the measure-from point.
+    expect(rule?.measureFrom).toEqual(new Date(2026, 0, 1));
+  });
+
+  test("renaming a default carries an overriding item's override and its service history to the new name, keeping the override's own thresholds", async () => {
+    const owner = await newOwner("u3defRenameOverride");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const def = await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    await createItemRule(owner, "firearm", fa.id, {
+      name: "Cleaning",
+      intervalRounds: 300,
+    });
+    await makeServiceEvent(
+      { firearmId: fa.id },
+      { ruleName: "Cleaning", servicedOn: "2026-01-01" },
+    );
+
+    await updateServiceRuleDefault(owner, def.id, {
+      name: "Deep Clean",
+      intervalRounds: 500,
+    });
+
+    const itemRules = await listItemRules(owner, "firearm", fa.id);
+    expect(itemRules).toHaveLength(1);
+    expect(itemRules[0]).toMatchObject({
+      name: "Deep Clean",
+      intervalRounds: 300, // the override's OWN threshold, untouched by the default's
+    });
+
+    const events = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa.id));
+    expect(events.map((e) => e.ruleName)).toEqual(["Deep Clean"]);
+
+    const resolved = await getItemDueState(owner, "firearm", fa.id);
+    expect(resolved.find((r) => r.name === "Deep Clean")).toMatchObject({
+      inheritanceState: "overridden",
+      intervalRounds: 300,
+    });
+  });
+
+  test("renaming a default never touches another owner's identically-named default or that owner's items in the same category", async () => {
+    const ownerA = await newOwner("u3defRenameOwnerA");
+    const ownerB = await newOwner("u3defRenameOwnerB");
+    const faA = await makeFirearm(ownerA, { type: "rifle" });
+    const faB = await makeFirearm(ownerB, { type: "rifle" });
+
+    const defA = await createServiceRuleDefault(ownerA, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    await createServiceRuleDefault(ownerB, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 999,
+    });
+    await makeServiceEvent(
+      { firearmId: faA.id },
+      { ruleName: "Cleaning", servicedOn: "2026-01-01" },
+    );
+    await makeServiceEvent(
+      { firearmId: faB.id },
+      { ruleName: "Cleaning", servicedOn: "2026-01-02" },
+    );
+
+    await updateServiceRuleDefault(ownerA, defA.id, {
+      name: "Deep Clean",
+      intervalRounds: 500,
+    });
+
+    const bDefaults = await listServiceRuleDefaults(ownerB, "firearm", "rifle");
+    expect(bDefaults.map((d) => d.name)).toEqual(["Cleaning"]);
+
+    const bEvents = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, faB.id));
+    expect(bEvents.map((e) => e.ruleName)).toEqual(["Cleaning"]);
+  });
+
+  test("renaming a default onto a name a sibling default in the same scope+category already uses throws ValidationError and writes nothing", async () => {
+    const owner = await newOwner("u3defRenameDup");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const cleaning = await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Barrel",
+      intervalRounds: 5000,
+    });
+    await makeServiceEvent(
+      { firearmId: fa.id },
+      { ruleName: "Cleaning", servicedOn: "2026-01-01" },
+    );
+
+    await expect(
+      updateServiceRuleDefault(owner, cleaning.id, {
+        name: "Barrel",
+        intervalRounds: 500,
+      }),
+    ).rejects.toBeInstanceOf(ValidationError);
+
+    const defaults = await listServiceRuleDefaults(owner, "firearm", "rifle");
+    expect(defaults.map((d) => d.name).sort()).toEqual(["Barrel", "Cleaning"]);
+
+    const events = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa.id));
+    expect(events.map((e) => e.ruleName)).toEqual(["Cleaning"]);
+  });
+
+  test("two sequential renames of the same default leave an inheriting item's history on the final name, not stranded on the intermediate one", async () => {
+    const owner = await newOwner("u3defRenameSequential");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const def = await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    await makeServiceEvent(
+      { firearmId: fa.id },
+      { ruleName: "Cleaning", servicedOn: "2026-01-01" },
+    );
+
+    await updateServiceRuleDefault(owner, def.id, {
+      name: "Deep Clean",
+      intervalRounds: 500,
+    });
+    await updateServiceRuleDefault(owner, def.id, {
+      name: "Field Strip",
+      intervalRounds: 500,
+    });
+
+    const events = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa.id));
+    expect(events.map((e) => e.ruleName)).toEqual(["Field Strip"]);
+
+    const defaults = await listServiceRuleDefaults(owner, "firearm", "rifle");
+    expect(defaults.map((d) => d.name)).toEqual(["Field Strip"]);
+  });
+
+  test("a firearm's view-grantee reading an accessory's rules is rejected, even when that accessory is mounted on the shared firearm", async () => {
+    const owner = await newOwner("u3accOwner");
+    const viewer = await newOwner("u3accViewer");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const acc = await makeAccessory(owner, { currentFirearmId: fa.id });
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: viewer,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "view",
+    });
+
+    await expect(
+      getItemDueState(viewer, "accessory", acc.id),
+    ).rejects.toBeInstanceOf(NotFoundError);
+    await expect(
+      listItemRules(viewer, "accessory", acc.id),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  test("an invalid rule (empty name, no thresholds and not suppressed) throws ValidationError and writes no row", async () => {
+    const owner = await newOwner("u3invalidOwner");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+
+    await expect(
+      createItemRule(owner, "firearm", fa.id, { name: "   " }),
+    ).rejects.toBeInstanceOf(ValidationError);
+
+    const rules = await listItemRules(owner, "firearm", fa.id);
+    expect(rules).toHaveLength(0);
+  });
+
+  // F7: a suppressed rule submitted WITH a threshold is a caller bug, and is
+  // rejected explicitly rather than silently normalized (see `validate.ts`'s
+  // `suppressedWithThresholds` doc for the full rationale).
+  test("F7: creating a rule that is both suppressed and carries a threshold throws ValidationError and writes no row", async () => {
+    const owner = await newOwner("u3f7Owner");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+
+    await expect(
+      createItemRule(owner, "firearm", fa.id, {
+        name: "Cleaning",
+        suppressed: true,
+        intervalRounds: 500,
+      }),
+    ).rejects.toBeInstanceOf(ValidationError);
+
+    const rules = await listItemRules(owner, "firearm", fa.id);
+    expect(rules).toHaveLength(0);
+  });
+
+  test("F7: updating a rule to be both suppressed and carry a threshold throws ValidationError and leaves the row unchanged", async () => {
+    const owner = await newOwner("u3f7UpdateOwner");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const rule = await createItemRule(owner, "firearm", fa.id, {
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+
+    await expect(
+      updateItemRule(owner, "firearm", fa.id, rule.id, {
+        name: "Cleaning",
+        suppressed: true,
+        intervalRounds: 500,
+      }),
+    ).rejects.toBeInstanceOf(ValidationError);
+
+    const rules = await listItemRules(owner, "firearm", fa.id);
+    expect(rules[0]).toMatchObject({
+      name: "Cleaning",
+      suppressed: false,
+      intervalRounds: 500,
+    });
+  });
+
+  // F5: two overlapping renames of the same rule must never leave history
+  // stranded on the intermediate name — the second writer has to re-read the
+  // name the first writer actually left behind, not the name both started
+  // from.
+  test("F5: two concurrent renames of the same rule leave history following whichever name won, not stranded on the intermediate name", async () => {
+    const owner = await newOwner("u3f5concurrent");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+    const rule = await createItemRule(owner, "firearm", fa.id, {
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    await makeServiceEvent(
+      { firearmId: fa.id },
+      { ruleName: "Cleaning", servicedOn: "2026-01-01" },
+    );
+
+    await Promise.all([
+      updateItemRule(owner, "firearm", fa.id, rule.id, {
+        name: "Deep Clean",
+        intervalRounds: 500,
+      }),
+      updateItemRule(owner, "firearm", fa.id, rule.id, {
+        name: "Field Strip",
+        intervalRounds: 500,
+      }),
+    ]);
+
+    const finalRules = await listItemRules(owner, "firearm", fa.id);
+    expect(finalRules).toHaveLength(1);
+    const finalName = finalRules[0].name;
+    expect(["Deep Clean", "Field Strip"]).toContain(finalName);
+
+    const events = await db
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.firearmId, fa.id));
+    expect(events.map((e) => e.ruleName)).toEqual([finalName]);
+  });
+
+  // Backstop for the race `assertNameAvailable`'s pre-check can't close on its
+  // own: under READ COMMITTED, two concurrent creates of the same name can
+  // both pass the pre-check read before either insert commits. The DB's
+  // unique constraint (`service_rule_firearm_name_unique`) then rejects the
+  // loser — this must surface as the same clean `ValidationError(["duplicateName"])`
+  // the pre-check itself throws, never the raw Postgres driver error.
+  test("two concurrent creates of the same item-rule name: one wins, the other gets ValidationError(duplicateName), never a raw driver error", async () => {
+    const owner = await newOwner("u3raceItemRule");
+    const fa = await makeFirearm(owner, { type: "rifle" });
+
+    const results = await Promise.allSettled([
+      createItemRule(owner, "firearm", fa.id, {
+        name: "Cleaning",
+        intervalRounds: 500,
+      }),
+      createItemRule(owner, "firearm", fa.id, {
+        name: "Cleaning",
+        intervalRounds: 500,
+      }),
+    ]);
+
+    const fulfilled = results.filter((r) => r.status === "fulfilled");
+    const rejected = results.filter((r) => r.status === "rejected");
+    expect(fulfilled).toHaveLength(1);
+    expect(rejected).toHaveLength(1);
+    const rejection = rejected[0] as PromiseRejectedResult;
+    expect(rejection.reason).toBeInstanceOf(ValidationError);
+    expect((rejection.reason as ValidationError).codes).toEqual([
+      "duplicateName",
+    ]);
+
+    const finalRules = await listItemRules(owner, "firearm", fa.id);
+    expect(finalRules).toHaveLength(1);
+  });
+
+  // Same backstop, for category defaults (`service_rule_default_owner_scope_category_name_unique`).
+  test("two concurrent creates of the same default name: one wins, the other gets ValidationError(duplicateName), never a raw driver error", async () => {
+    const owner = await newOwner("u3raceDefault");
+
+    const results = await Promise.allSettled([
+      createServiceRuleDefault(owner, {
+        scope: "firearm",
+        category: "rifle",
+        name: "Cleaning",
+        intervalRounds: 500,
+      }),
+      createServiceRuleDefault(owner, {
+        scope: "firearm",
+        category: "rifle",
+        name: "Cleaning",
+        intervalRounds: 500,
+      }),
+    ]);
+
+    const fulfilled = results.filter((r) => r.status === "fulfilled");
+    const rejected = results.filter((r) => r.status === "rejected");
+    expect(fulfilled).toHaveLength(1);
+    expect(rejected).toHaveLength(1);
+    const rejection = rejected[0] as PromiseRejectedResult;
+    expect(rejection.reason).toBeInstanceOf(ValidationError);
+    expect((rejection.reason as ValidationError).codes).toEqual([
+      "duplicateName",
+    ]);
+
+    const finalDefaults = await listServiceRuleDefaults(
+      owner,
+      "firearm",
+      "rifle",
+    );
+    expect(finalDefaults).toHaveLength(1);
+  });
+
+  test("the accessory-category listing returns each of the owner's distinct categories once, alphabetically, and excludes another owner's categories", async () => {
+    const owner = await newOwner("u3catOwner");
+    const other = await newOwner("u3catOther");
+    await makeAccessory(owner, { category: "Optic" });
+    await makeAccessory(owner, { category: "Optic" });
+    await makeAccessory(owner, { category: "Sling" });
+    await makeAccessory(owner, { category: "Grip" });
+    await makeAccessory(other, { category: "Muzzle Device" });
+
+    const categories = await listOwnerAccessoryCategories(owner);
+    expect(categories).toEqual(["Grip", "Optic", "Sling"]);
+  });
+
+  test("covers U7: countItemsInCategory counts only the owner's items of that scope+category", async () => {
+    const owner = await newOwner("u7count");
+    const other = await newOwner("u7countOther");
+    await makeFirearm(owner, { type: "rifle" });
+    await makeFirearm(owner, { type: "rifle" });
+    await makeFirearm(owner, { type: "pistol" });
+    await makeFirearm(other, { type: "rifle" });
+    await makeAccessory(owner, { category: "Optic" });
+
+    expect(await countItemsInCategory(owner, "firearm", "rifle")).toBe(2);
+    expect(await countItemsInCategory(owner, "firearm", "pistol")).toBe(1);
+    expect(await countItemsInCategory(owner, "firearm", "shotgun")).toBe(0);
+    expect(await countItemsInCategory(owner, "accessory", "Optic")).toBe(1);
+    expect(await countItemsInCategory(owner, "accessory", "Sling")).toBe(0);
+  });
+
+  test("covers U7: listConfiguredCategories surfaces a category armed ahead of any accessory, and stays after the accessory is gone", async () => {
+    const owner = await newOwner("u7configured");
+    await createServiceRuleDefault(owner, {
+      scope: "accessory",
+      category: "Muzzle Device",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+
+    const configured = await listConfiguredCategories(owner, "accessory");
+    expect(configured).toEqual(["Muzzle Device"]);
+
+    const existing = await listOwnerAccessoryCategories(owner);
+    expect(existing).toEqual([]);
+  });
+
+  test("covers U7: deleting a default removes the inherited rule from every item that had not overridden it", async () => {
+    const owner = await newOwner("u7deleteDefault");
+    const overridden = await makeFirearm(owner, { type: "rifle" });
+    const plain = await makeFirearm(owner, { type: "rifle" });
+    const def = await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+    await createItemRule(owner, "firearm", overridden.id, {
+      name: "Cleaning",
+      intervalRounds: 300,
+    });
+
+    await deleteServiceRuleDefault(owner, def.id);
+
+    const overriddenRules = await getItemDueState(
+      owner,
+      "firearm",
+      overridden.id,
+    );
+    const plainRules = await getItemDueState(owner, "firearm", plain.id);
+    // The override row still stands (it's the item's own row, untouched by
+    // the default's deletion) — with no default left to match it against, it
+    // now resolves item-only rather than overridden. The item with no
+    // override of its own loses the rule entirely.
+    expect(overriddenRules.find((r) => r.name === "Cleaning")).toMatchObject({
+      intervalRounds: 300,
+      inheritanceState: "item-only",
+    });
+    expect(plainRules.find((r) => r.name === "Cleaning")).toBeUndefined();
+  });
+
+  test("covers U7: listConfiguredCategories drops a category once its only default is deleted", async () => {
+    const owner = await newOwner("u7configuredDelete");
+    const def = await createServiceRuleDefault(owner, {
+      scope: "accessory",
+      category: "Sling",
+      name: "Cleaning",
+      intervalRounds: 500,
+    });
+
+    await deleteServiceRuleDefault(owner, def.id);
+
+    const configured = await listConfiguredCategories(owner, "accessory");
+    expect(configured).toEqual([]);
+  });
+});
diff --git a/src/domain/service-intervals/__tests__/validate-event.test.ts b/src/domain/service-intervals/__tests__/validate-event.test.ts
new file mode 100644
index 00000000..55afb78d
--- /dev/null
+++ b/src/domain/service-intervals/__tests__/validate-event.test.ts
@@ -0,0 +1,115 @@
+import { describe, expect, test } from "bun:test";
+import {
+  type ServiceEventInput,
+  validateServicedOn,
+  validateServiceEventInput,
+} from "../validate-event";
+
+/**
+ * Pure validator tests (F8: `validate-event.ts` had no test file at all).
+ * Mirrors `firearms/__tests__/validate.test.ts`'s style. Date fixtures are
+ * always built with local Y/M/D components (`new Date(y, monthIndex, d)`),
+ * never UTC `...Z` literals, per KTD5 — this file is run under UTC,
+ * TZ=Asia/Tokyo, and TZ=America/New_York.
+ */
+function localDate(year: number, monthIndex: number, day: number): Date {
+  return new Date(year, monthIndex, day);
+}
+
+describe("validateServicedOn", () => {
+  test("an empty string returns emptyServicedOn", () => {
+    expect(validateServicedOn("")).toEqual(["emptyServicedOn"]);
+  });
+
+  test("a whitespace-only string is treated as empty", () => {
+    expect(validateServicedOn("   ")).toEqual(["emptyServicedOn"]);
+  });
+
+  test.each(["not-a-date", "2026-13-01", "2026-02-30"])(
+    "%s is not a real calendar date and returns invalidServicedOn",
+    (value) => {
+      const asOf = localDate(2026, 5, 15);
+      expect(validateServicedOn(value, asOf)).toEqual(["invalidServicedOn"]);
+    },
+  );
+
+  test("a real calendar date on or before asOf is valid", () => {
+    const asOf = localDate(2026, 5, 15);
+    expect(validateServicedOn("2026-06-15", asOf)).toEqual([]);
+    expect(validateServicedOn("2026-06-01", asOf)).toEqual([]);
+  });
+
+  // F1: asOf defaults to the SERVER's clock, not the submitter's — a
+  // submitter's local calendar day can genuinely run up to one day ahead of
+  // it (no real timezone is more than ~26 hours ahead of another), so a
+  // one-day tolerance is required before a submitted date is treated as
+  // genuinely in the future.
+  describe("F1: one-day future tolerance", () => {
+    test("the server's own today is accepted", () => {
+      const asOf = localDate(2026, 5, 15);
+      expect(validateServicedOn("2026-06-15", asOf)).toEqual([]);
+    });
+
+    test("one day after the server's today is accepted (the timezone-ahead submitter case)", () => {
+      const asOf = localDate(2026, 5, 15);
+      expect(validateServicedOn("2026-06-16", asOf)).toEqual([]);
+    });
+
+    test("two days after the server's today is rejected as genuinely in the future", () => {
+      const asOf = localDate(2026, 5, 15);
+      expect(validateServicedOn("2026-06-17", asOf)).toEqual([
+        "servicedOnInFuture",
+      ]);
+    });
+
+    test("many days after the server's today is rejected", () => {
+      const asOf = localDate(2026, 5, 15);
+      expect(validateServicedOn("2026-07-01", asOf)).toEqual([
+        "servicedOnInFuture",
+      ]);
+    });
+  });
+});
+
+describe("validateServiceEventInput", () => {
+  const asOf = localDate(2026, 5, 15);
+
+  test("a valid rule name and date pass with no codes", () => {
+    const input: ServiceEventInput = {
+      ruleName: "Cleaning",
+      servicedOn: "2026-06-01",
+    };
+    expect(validateServiceEventInput(input, asOf)).toEqual([]);
+  });
+
+  test("an empty rule name returns emptyRuleName", () => {
+    const input: ServiceEventInput = { ruleName: "", servicedOn: "2026-06-01" };
+    expect(validateServiceEventInput(input, asOf)).toEqual(["emptyRuleName"]);
+  });
+
+  test("a whitespace-only rule name is treated as empty", () => {
+    const input: ServiceEventInput = {
+      ruleName: "   ",
+      servicedOn: "2026-06-01",
+    };
+    expect(validateServiceEventInput(input, asOf)).toEqual(["emptyRuleName"]);
+  });
+
+  test("an empty rule name and an empty date combine, not short-circuit", () => {
+    const input: ServiceEventInput = { ruleName: "", servicedOn: "" };
+    expect(validateServiceEventInput(input, asOf)).toEqual([
+      "emptyRuleName",
+      "emptyServicedOn",
+    ]);
+  });
+
+  test("a future date more than the one-day tolerance combines with a valid rule name into just servicedOnInFuture", () => {
+    const input: ServiceEventInput = {
+      ruleName: "Cleaning",
+      servicedOn: "2026-06-20",
+    };
+    expect(validateServiceEventInput(input, asOf)).toEqual([
+      "servicedOnInFuture",
+    ]);
+  });
+});
diff --git a/src/domain/service-intervals/__tests__/validate.test.ts b/src/domain/service-intervals/__tests__/validate.test.ts
new file mode 100644
index 00000000..c85598f8
--- /dev/null
+++ b/src/domain/service-intervals/__tests__/validate.test.ts
@@ -0,0 +1,130 @@
+import { describe, expect, test } from "bun:test";
+import { type ServiceRuleInput, validateServiceRuleSet } from "../validate";
+
+// Pure validator — no DB (U2). Returns EVERY applicable failure code together,
+// matching the shape of `validateLogEntry` / `validateMagazine`.
+describe("validateServiceRuleSet", () => {
+  test("accepts a valid rule with a single threshold set", () => {
+    const rules: ServiceRuleInput[] = [
+      { name: "Cleaning", intervalRounds: 500 },
+    ];
+    expect(validateServiceRuleSet(rules)).toEqual([]);
+  });
+
+  test("rejects an empty rule name", () => {
+    const rules: ServiceRuleInput[] = [{ name: "", intervalDays: 30 }];
+    expect(validateServiceRuleSet(rules)).toContain("emptyName");
+  });
+
+  test("rejects a whitespace-only rule name", () => {
+    const rules: ServiceRuleInput[] = [{ name: "   ", intervalDays: 30 }];
+    expect(validateServiceRuleSet(rules)).toContain("emptyName");
+  });
+
+  test("rejects a duplicate name within one submitted set", () => {
+    const rules: ServiceRuleInput[] = [
+      { name: "Cleaning", intervalRounds: 500 },
+      { name: "Cleaning", intervalDays: 90 },
+    ];
+    expect(validateServiceRuleSet(rules)).toContain("duplicateName");
+  });
+
+  test("accepts the same name across two separate validation calls (only one submitted set)", () => {
+    const first = validateServiceRuleSet([
+      { name: "Cleaning", intervalRounds: 500 },
+    ]);
+    const second = validateServiceRuleSet([
+      { name: "Cleaning", intervalDays: 90 },
+    ]);
+    expect(first).toEqual([]);
+    expect(second).toEqual([]);
+  });
+
+  test("rejects a zero threshold", () => {
+    const rules: ServiceRuleInput[] = [{ name: "Cleaning", intervalRounds: 0 }];
+    expect(validateServiceRuleSet(rules)).toContain("thresholdTooLow");
+  });
+
+  test("rejects a negative threshold", () => {
+    const rules: ServiceRuleInput[] = [{ name: "Cleaning", intervalDays: -1 }];
+    expect(validateServiceRuleSet(rules)).toContain("thresholdTooLow");
+  });
+
+  // The form's `toRuleInput` converts threshold strings with `Number()`, not
+  // `Number.parseInt` — a value like "1.5" becomes 1.5, which would otherwise
+  // pass the below-minimum check (1.5 < 1 is false) and later fail as an
+  // unhandled driver error against the integer DB columns.
+  test("rejects a fractional threshold", () => {
+    const rules: ServiceRuleInput[] = [
+      { name: "Cleaning", intervalRounds: 1.5 },
+    ];
+    expect(validateServiceRuleSet(rules)).toContain("thresholdTooLow");
+  });
+
+  test("rejects a NaN threshold", () => {
+    const rules: ServiceRuleInput[] = [
+      { name: "Cleaning", intervalRounds: Number.NaN },
+    ];
+    expect(validateServiceRuleSet(rules)).toContain("thresholdTooLow");
+  });
+
+  test("accepts a rule whose only threshold is intervalSessions", () => {
+    const rules: ServiceRuleInput[] = [
+      { name: "Cleaning", intervalSessions: 5 },
+    ];
+    expect(validateServiceRuleSet(rules)).toEqual([]);
+  });
+
+  test("rejects a zero intervalSessions threshold", () => {
+    const rules: ServiceRuleInput[] = [
+      { name: "Cleaning", intervalSessions: 0 },
+    ];
+    expect(validateServiceRuleSet(rules)).toContain("thresholdTooLow");
+  });
+
+  test("rejects a rule with no threshold set and not suppressed", () => {
+    const rules: ServiceRuleInput[] = [{ name: "Cleaning" }];
+    expect(validateServiceRuleSet(rules)).toContain("missingThreshold");
+  });
+
+  test("accepts a suppressed rule with no threshold set", () => {
+    const rules: ServiceRuleInput[] = [{ name: "Cleaning", suppressed: true }];
+    expect(validateServiceRuleSet(rules)).toEqual([]);
+  });
+
+  // F7: suppression and thresholds are mutually exclusive on one row (KTD6).
+  // A caller submitting both together is a bug — reject it explicitly rather
+  // than silently discarding the submitted thresholds.
+  test("F7: rejects a suppressed rule that also sets a threshold", () => {
+    const rules: ServiceRuleInput[] = [
+      { name: "Cleaning", suppressed: true, intervalRounds: 500 },
+    ];
+    expect(validateServiceRuleSet(rules)).toEqual(["suppressedWithThresholds"]);
+  });
+
+  test("F7: a suppressed rule with a threshold does NOT also raise missingThreshold", () => {
+    const rules: ServiceRuleInput[] = [
+      { name: "Cleaning", suppressed: true, intervalDays: 30 },
+    ];
+    const codes = validateServiceRuleSet(rules);
+    expect(codes).toContain("suppressedWithThresholds");
+    expect(codes).not.toContain("missingThreshold");
+  });
+
+  test("returns every applicable code together in one call", () => {
+    const rules: ServiceRuleInput[] = [
+      { name: "", intervalRounds: 500 },
+      { name: "   ", intervalDays: 30 },
+      { name: "Cleaning", intervalRounds: 500 },
+      { name: "Cleaning", intervalDays: 90 },
+      { name: "Barrel", intervalRounds: 0 },
+      { name: "Spring", intervalDays: -5 },
+      { name: "NoThreshold" },
+    ];
+    const codes = validateServiceRuleSet(rules);
+    expect(codes).toContain("emptyName");
+    expect(codes).toContain("duplicateName");
+    expect(codes).toContain("thresholdTooLow");
+    expect(codes).toContain("missingThreshold");
+  });
+});
diff --git a/src/domain/service-intervals/actor-names.ts b/src/domain/service-intervals/actor-names.ts
new file mode 100644
index 00000000..9315a285
--- /dev/null
+++ b/src/domain/service-intervals/actor-names.ts
@@ -0,0 +1,56 @@
+import { namesByIds } from "@/src/auth/users";
+import type { ServiceEventRow } from "./events-service";
+
+/** Display label when `actorId` is `null` — the authoring account was later deleted. */
+export const UNKNOWN_ACTOR_LABEL = "Unknown";
+
+/**
+ * One service-history row ready for display: a raw `ServiceEventRow` with its
+ * `actorId` resolved to a display name (or `UNKNOWN_ACTOR_LABEL`). Structurally
+ * identical to `ServiceHistoryEntry` (`app/(app)/firearms/service-history.tsx`)
+ * — kept as a separate domain-owned type rather than importing that UI type
+ * here, so this module (used by both the firearm and accessory detail pages)
+ * has no dependency on the `app/` layer.
+ */
+export interface ServiceHistoryDisplayEntry {
+  id: string;
+  ruleName: string;
+  servicedOn: string;
+  actorName: string;
+  notes: string;
+}
+
+/**
+ * Attach each service-history event's actor display name (mirrors
+ * `inventory-log/log-actions.ts`'s `listLogAction` — resolves `name`, not
+ * `email`, since a view-grantee on a shared firearm can read this too).
+ * Shared by the firearm and accessory detail pages so the same
+ * `UNKNOWN_ACTOR_LABEL` and raw-id fallback policy can't drift between them.
+ */
+export async function withActorNames(
+  events: ServiceEventRow[],
+): Promise<ServiceHistoryDisplayEntry[]> {
+  const actorIds = [
+    ...new Set(
+      events
+        .map((event) => event.actorId)
+        .filter((actorId): actorId is string => actorId !== null),
+    ),
+  ];
+  const nameById = await namesByIds(actorIds);
+  return events.map((event) => ({
+    id: event.id,
+    ruleName: event.ruleName,
+    servicedOn: event.servicedOn,
+    // A non-null `actorId` with no matching row (the account was deleted
+    // between the event write and this read) falls back to
+    // `UNKNOWN_ACTOR_LABEL` too, never the raw account id — leaking a raw id
+    // into the UI is exactly what resolving a display name here exists to
+    // avoid.
+    actorName:
+      event.actorId === null
+        ? UNKNOWN_ACTOR_LABEL
+        : (nameById.get(event.actorId) ?? UNKNOWN_ACTOR_LABEL),
+    notes: event.notes,
+  }));
+}
diff --git a/src/domain/service-intervals/backlog.ts b/src/domain/service-intervals/backlog.ts
new file mode 100644
index 00000000..3b856560
--- /dev/null
+++ b/src/domain/service-intervals/backlog.ts
@@ -0,0 +1,87 @@
+import type { ItemDueEntry } from "./due-service";
+import type { ServiceParentType } from "./rules-service";
+
+/**
+ * Service backlog (R16, U9-adjacent) — pure. Flattens
+ * `listDueForVisibleCollection`'s per-item, per-rule due state into one row
+ * per DUE item-and-rule pair, each named for display, so `/summary`'s bulk
+ * mark-serviced control (the R16 surface: "mark one or many items serviced
+ * as of a date in a single action") can show the owner exactly what a
+ * selection will mark BEFORE they commit to it, without re-deriving due
+ * state (KTD4 — this only reshapes what `due-service.ts` already computed).
+ *
+ * No DB access here: item display names are supplied by the caller (already
+ * loaded, batched, alongside the due entries themselves), matching the
+ * load-then-apply-pure-function split every other layer in this feature
+ * follows.
+ *
+ * `entries` comes from `listDueForVisibleCollection`, which is ALSO what
+ * feeds the `/summary` roll-up counts (`inventorySummary`) — it deliberately
+ * includes a shared firearm at every visibility tier, because an owner's due
+ * state on a shared item is legitimate information for a view-grantee to
+ * see (R19's roll-up). This checklist is a WRITE surface, not a read one:
+ * `logServiceEventsBulk`'s per-family authorization (KTD3) allows a firearm
+ * edit-grantee to log service but never a view-only one, and accessories are
+ * owner-only throughout. Offering a view-grantee a checkbox that
+ * authorization will only ever reject is a read surface promising a write
+ * action it can't deliver — and because the bulk write is one transaction,
+ * checking that box also rolls back every other legitimate row in the same
+ * submission. `actionableFirearmIds` — the firearm ids the actor holds
+ * owner or edit permission on, per `visibleFirearmPermissions` — filters
+ * those rows out here, at the one place this checklist is built, rather
+ * than by loosening `logServiceEventsBulk`'s authorization itself. Accessory
+ * rows need no equivalent filter: `listDueForVisibleCollection` already
+ * scopes its accessory set to `owner_id = actorId` (KTD3), so every
+ * accessory entry reaching this function is already actionable.
+ */
+
+/** A generic label used when a name map has no entry for an item (defensive; should not happen in practice). */
+const UNKNOWN_ITEM_LABEL = "Unknown item";
+
+export interface BacklogRow {
+  parentType: ServiceParentType;
+  parentId: string;
+  /** Display name resolved by the caller (firearm nickname/name, or accessory brand/model/category). */
+  itemName: string;
+  ruleName: string;
+}
+
+/**
+ * One row per DUE rule across the visible collection (items with zero due
+ * rules contribute nothing). Sorted by item name, then rule name, for a
+ * stable, readable display order — `listDueForVisibleCollection`'s own
+ * ordering is by load order, not display order.
+ */
+export function buildServiceBacklog(
+  entries: ItemDueEntry[],
+  firearmNames: Map<string, string>,
+  accessoryNames: Map<string, string>,
+  actionableFirearmIds: Set<string>,
+): BacklogRow[] {
+  const rows: BacklogRow[] = [];
+  for (const entry of entries) {
+    if (
+      entry.parentType === "firearm" &&
+      !actionableFirearmIds.has(entry.parentId)
+    ) {
+      continue; // view-only grantee: excluded from the write checklist (KTD3), still counted in the roll-up
+    }
+    const names =
+      entry.parentType === "firearm" ? firearmNames : accessoryNames;
+    const itemName = names.get(entry.parentId) ?? UNKNOWN_ITEM_LABEL;
+    for (const rule of entry.rules) {
+      if (!rule.due) continue;
+      rows.push({
+        parentType: entry.parentType,
+        parentId: entry.parentId,
+        itemName,
+        ruleName: rule.name,
+      });
+    }
+  }
+  return rows.sort(
+    (a, b) =>
+      a.itemName.localeCompare(b.itemName) ||
+      a.ruleName.localeCompare(b.ruleName),
+  );
+}
diff --git a/src/domain/service-intervals/constants.ts b/src/domain/service-intervals/constants.ts
new file mode 100644
index 00000000..5e6154b1
--- /dev/null
+++ b/src/domain/service-intervals/constants.ts
@@ -0,0 +1,44 @@
+/**
+ * Service-interval constants (service-intervals plan, U2). Single source for
+ * the rule-name/threshold bounds and the inheritance-state union, mirrored by
+ * the DB CHECKs in `src/db/inventory-schema.ts` (`service_rule_default`,
+ * `service_rule` — every non-null threshold >= 1) and consumed by both
+ * `validate.ts` (write path) and `derive.ts` (read path).
+ */
+
+/** Minimum value a set threshold (days/sessions/rounds) may carry (R2). */
+export const MIN_THRESHOLD = 1;
+
+/**
+ * How a resolved rule relates to its item's category default (R5):
+ * - `inherited` — no item entry for this rule name; tracks the default as-is.
+ * - `overridden` — an item entry exists with its own thresholds.
+ * - `item-only` — an item entry exists with no matching default at all.
+ *
+ * A suppressed item entry is not itself a state here — it removes the rule
+ * from the resolved set entirely (KTD6), so it never reaches this union.
+ */
+export const INHERITANCE_STATES = [
+  "inherited",
+  "overridden",
+  "item-only",
+] as const;
+
+export type InheritanceState = (typeof INHERITANCE_STATES)[number];
+
+/** The three axes a rule can set a threshold on (R2, R7). */
+export const SERVICE_AXES = ["days", "sessions", "rounds"] as const;
+
+export type ServiceAxis = (typeof SERVICE_AXES)[number];
+
+/**
+ * Maximum item+rule pairs one `logServiceEventsBulk` call (R16) may include
+ * (F6 fix). A single INSERT binds several parameters per row, so an
+ * unbounded batch could exceed the DB driver's bound-parameter ceiling as an
+ * unhandled error mid-transaction, holding row locks open in the meantime.
+ * Rejecting an over-size batch as a `ValidationError` BEFORE opening the
+ * transaction turns that into a clean, expected failure instead. A few
+ * hundred is comfortably more than any real "mark this whole visible
+ * collection serviced" click would ever submit.
+ */
+export const MAX_BULK_SERVICE_ITEMS = 200;
diff --git a/src/domain/service-intervals/derive.ts b/src/domain/service-intervals/derive.ts
new file mode 100644
index 00000000..f3ddaa70
--- /dev/null
+++ b/src/domain/service-intervals/derive.ts
@@ -0,0 +1,188 @@
+/**
+ * Service-interval derivation core (service-intervals plan, U2). Pure — no
+ * DB, no Drizzle, no `src/db/client`. Every surface (item detail, `/summary`
+ * roll-up, list indicators) reads this module's output; nothing above it
+ * decides due state (KTD4).
+ *
+ * Every calendar comparison happens in the local frame (KTD5): dates are
+ * plain `Date` values built from local year/month/day components (never a
+ * UTC `...Z` instant), and day differences are computed with `date-fns`'s
+ * `differenceInCalendarDays`, which compares local calendar days regardless
+ * of the runner's timezone offset.
+ */
+
+import { differenceInCalendarDays } from "date-fns";
+import type { InheritanceState, ServiceAxis } from "./constants";
+
+/** The three threshold axes a rule may set (nullable = "not tracked on this axis"). */
+export interface Thresholds {
+  intervalDays: number | null;
+  intervalSessions: number | null;
+  intervalRounds: number | null;
+}
+
+/** A category default rule (owner-scoped, keyed by category + name). */
+export interface DefaultRule extends Thresholds {
+  name: string;
+}
+
+/**
+ * An item's own rule row — an override (thresholds set, not suppressed), a
+ * suppression (`suppressed: true`, no thresholds), or an item-only rule with
+ * no matching default (also thresholds set, not suppressed; indistinguishable
+ * from an override at this shape — `resolveEffectiveRules` is what tells them
+ * apart, by checking against the defaults set).
+ */
+export interface ItemRule extends Thresholds {
+  name: string;
+  suppressed: boolean;
+}
+
+/** One rule in an item's effective, resolved rule set. */
+export interface ResolvedRule extends Thresholds {
+  name: string;
+  inheritanceState: InheritanceState;
+}
+
+function extractThresholds(rule: Thresholds): Thresholds {
+  return {
+    intervalDays: rule.intervalDays,
+    intervalSessions: rule.intervalSessions,
+    intervalRounds: rule.intervalRounds,
+  };
+}
+
+/**
+ * Resolve an item's effective rule set from its owner's category defaults and
+ * the item's own rule rows (R4, R5, KTD6).
+ *
+ * - A default with no matching item rule resolves `inherited`.
+ * - A default with a matching, unsuppressed item rule resolves `overridden`,
+ *   using the item's own thresholds.
+ * - A default with a matching, SUPPRESSED item rule contributes nothing — the
+ *   suppression removes that default from the resolved set entirely.
+ * - An item rule with no matching default resolves `item-only`, unaffected by
+ *   any default in the set.
+ * - A suppressed item rule with no matching default contributes nothing and
+ *   raises no error.
+ */
+export function resolveEffectiveRules(
+  defaults: DefaultRule[],
+  itemRules: ItemRule[],
+): ResolvedRule[] {
+  const itemRuleByName = new Map(itemRules.map((rule) => [rule.name, rule]));
+  const matchedItemRuleNames = new Set<string>();
+  const resolved: ResolvedRule[] = [];
+
+  for (const def of defaults) {
+    const itemRule = itemRuleByName.get(def.name);
+    if (itemRule === undefined) {
+      resolved.push({
+        name: def.name,
+        inheritanceState: "inherited",
+        ...extractThresholds(def),
+      });
+      continue;
+    }
+
+    matchedItemRuleNames.add(itemRule.name);
+    if (itemRule.suppressed) continue; // KTD6: suppression removes the default.
+
+    resolved.push({
+      name: itemRule.name,
+      inheritanceState: "overridden",
+      ...extractThresholds(itemRule),
+    });
+  }
+
+  for (const itemRule of itemRules) {
+    if (matchedItemRuleNames.has(itemRule.name)) continue; // already resolved above
+    if (itemRule.suppressed) continue; // suppressed with no matching default: nothing
+
+    resolved.push({
+      name: itemRule.name,
+      inheritanceState: "item-only",
+      ...extractThresholds(itemRule),
+    });
+  }
+
+  return resolved;
+}
+
+/** One range session's date and rounds fired, as folded by `elapsedCounts`. */
+export interface SessionRow {
+  date: Date;
+  roundsFired: number;
+}
+
+export interface ElapsedCounts {
+  days: number;
+  sessions: number;
+  rounds: number;
+}
+
+/**
+ * Fold a measure-from date and an item's session rows into elapsed days,
+ * sessions, and rounds (R7, R8, R9, KTD4).
+ *
+ * `asOf` is the reference "now" the day axis measures against — an explicit
+ * parameter (never `Date.now()` internally) so this stays a pure, fully
+ * deterministic function.
+ *
+ * Sessions are counted only when STRICTLY AFTER the measure-from date
+ * (KTD10) — a session on the same calendar day as the measure-from date does
+ * not count toward sessions or rounds — AND no later than `asOf` (F4 fix).
+ * Range-session dates are deliberately allowed in the future by their own
+ * validation (unrelated to this fix, and not changed here), so without this
+ * upper bound a session logged for next month would immediately inflate
+ * today's session/round counts and could trip a threshold for something
+ * that has not happened yet. A session dated exactly `asOf` still counts —
+ * only STRICTLY later than `asOf` is excluded.
+ */
+export function elapsedCounts(
+  measureFrom: Date,
+  sessions: SessionRow[],
+  asOf: Date,
+): ElapsedCounts {
+  const days = Math.max(0, differenceInCalendarDays(asOf, measureFrom));
+
+  let sessionCount = 0;
+  let roundsTotal = 0;
+  for (const session of sessions) {
+    if (differenceInCalendarDays(session.date, measureFrom) <= 0) continue;
+    if (differenceInCalendarDays(session.date, asOf) > 0) continue;
+    sessionCount += 1;
+    roundsTotal += session.roundsFired;
+  }
+
+  return { days, sessions: sessionCount, rounds: roundsTotal };
+}
+
+export type DueResult =
+  | { due: true; trippedAxis: ServiceAxis }
+  | { due: false; trippedAxis: null };
+
+/**
+ * A rule is due when any threshold it sets is met or exceeded (R7, R11) — the
+ * comparison is met-or-exceeded, not strictly-exceeded. Checked in a fixed
+ * days/sessions/rounds order so the reported `trippedAxis` is deterministic
+ * when more than one axis has tripped.
+ */
+export function isDue(
+  thresholds: Thresholds,
+  counts: ElapsedCounts,
+): DueResult {
+  const checks: Array<[ServiceAxis, number | null, number]> = [
+    ["days", thresholds.intervalDays, counts.days],
+    ["sessions", thresholds.intervalSessions, counts.sessions],
+    ["rounds", thresholds.intervalRounds, counts.rounds],
+  ];
+
+  for (const [axis, threshold, elapsed] of checks) {
+    if (threshold !== null && elapsed >= threshold) {
+      return { due: true, trippedAxis: axis };
+    }
+  }
+
+  return { due: false, trippedAxis: null };
+}
diff --git a/src/domain/service-intervals/due-service.ts b/src/domain/service-intervals/due-service.ts
new file mode 100644
index 00000000..e99b25fb
--- /dev/null
+++ b/src/domain/service-intervals/due-service.ts
@@ -0,0 +1,683 @@
+import { parseISO } from "date-fns";
+import { and, eq, inArray, max } from "drizzle-orm";
+import { getVisibleIds } from "@/src/auth/visibility";
+import { type DbOrTx, db } from "@/src/db/client";
+import {
+  accessory,
+  firearm,
+  rangeSession,
+  rangeSessionAccessory,
+  serviceEvent,
+  serviceRule,
+  serviceRuleDefault,
+} from "@/src/db/schema";
+import { listFirearms } from "../firearms/service";
+import {
+  type DefaultRule,
+  type DueResult,
+  type ElapsedCounts,
+  elapsedCounts,
+  type ItemRule,
+  isDue,
+  type ResolvedRule,
+  resolveEffectiveRules,
+  type SessionRow,
+} from "./derive";
+import {
+  loadDefaults,
+  loadItemRules,
+  requireAccessoryOwner,
+  requireFirearmVisible,
+  resolveParent,
+  type ServiceParentType,
+  toDefaultRule,
+  toItemRule,
+} from "./rules-service";
+
+/**
+ * Due-resolution layer (service-intervals plan, U4). Loads what U2's pure
+ * `derive.ts` functions need — defaults, item rules, the last service point
+ * per rule, and session rows — and applies them. NOTHING here decides due
+ * state; every threshold comparison happens in `derive.ts` (KTD4).
+ *
+ * Two entry points:
+ * - `getItemDueState` resolves one item (firearm or accessory), authorized
+ *   the same way `rules-service.ts` reads are (a firearm by its own
+ *   visibility, R6; an accessory by direct ownership, KTD3).
+ * - `listDueForVisibleCollection` resolves EVERY visible item in a BOUNDED
+ *   number of queries, regardless of collection size (Definition of Done,
+ *   U4): one batched load per data source (owners' defaults, item rules,
+ *   last-service-points, session rows), never a per-item query.
+ *
+ * Origin date resolves per family (KTD9, updated during implementation): a
+ * firearm's `acquired_date` when set, else its `created_at`, as a calendar
+ * date; an accessory's `acquired_date` when set, else its `created_at`,
+ * EXACTLY parallel to the firearm resolution — accessories gained their own
+ * `acquired_date` after the plan's original scope (see the plan's "Scope
+ * added during implementation" note): leaving accessories on `created_at`
+ * alone reproduced R22's cold-start problem on the smaller half of the
+ * feature, where an accessory owned for years but entered today read as
+ * not-due on day one. `installed_date` still can't serve as an origin — it
+ * is force-nulled on unmount — but `acquired_date` is never touched by mount
+ * state, so it's stable. `acquired_date`/`serviced_on` are stored as Postgres `date` (a plain
+ * `YYYY-MM-DD` string); `parseISO` on a date-only string resolves to LOCAL
+ * midnight (KTD5), matching how `magazines/inventory-filter.ts` already
+ * parses stored calendar dates. `created_at` is already a `Date` instance
+ * (a `timestamp` column) and needs no parsing — `elapsedCounts`'s calendar-
+ * day comparison only ever reads its local Y/M/D, never its time-of-day.
+ */
+
+/**
+ * One resolved rule plus its computed elapsed counts and due state.
+ *
+ * Intersected with `DueResult` (a discriminated union) rather than declared
+ * as a flat interface with `due: boolean; trippedAxis: ServiceAxis | null`,
+ * so a `due: true` entry carries a guaranteed non-null `trippedAxis` at the
+ * type level, matching what `isDue` actually ever produces — no consumer has
+ * to null-check an axis the logic already guarantees is present.
+ */
+export type RuleDueState = ResolvedRule & {
+  measureFrom: Date;
+  counts: ElapsedCounts;
+} & DueResult;
+
+/**
+ * One visible item's resolved, due-annotated rule set. Omitted entirely from
+ * `listDueForVisibleCollection` when it has no effective rules — an item
+ * with nothing to track contributes nothing to the collection view.
+ */
+export interface ItemDueEntry {
+  parentType: ServiceParentType;
+  parentId: string;
+  rules: RuleDueState[];
+}
+
+function measureFromFor(
+  lastServicedOn: string | undefined,
+  originDate: Date,
+): Date {
+  return lastServicedOn !== undefined ? parseISO(lastServicedOn) : originDate;
+}
+
+function applyDue(
+  rule: ResolvedRule,
+  lastServicedOn: string | undefined,
+  originDate: Date,
+  sessions: SessionRow[],
+  asOf: Date,
+): RuleDueState {
+  const measureFrom = measureFromFor(lastServicedOn, originDate);
+  const counts = elapsedCounts(measureFrom, sessions, asOf);
+  const dueResult = isDue(rule, counts);
+  // Branch explicitly on the discriminant (rather than spreading `dueResult`
+  // directly) so each branch's literal `trippedAxis` type is preserved —
+  // spreading a union type into an object literal does not reliably narrow
+  // the result back to a union, which is what `RuleDueState` needs to keep
+  // its `due: true` branch's `trippedAxis` guaranteed non-null.
+  if (dueResult.due) {
+    return {
+      ...rule,
+      measureFrom,
+      counts,
+      due: true,
+      trippedAxis: dueResult.trippedAxis,
+    };
+  }
+  return { ...rule, measureFrom, counts, due: false, trippedAxis: null };
+}
+
+function resolveDueRules(
+  resolved: ResolvedRule[],
+  lastByRule: Map<string, string>,
+  originDate: Date,
+  sessions: SessionRow[],
+  asOf: Date,
+): RuleDueState[] {
+  return resolved.map((rule) =>
+    applyDue(rule, lastByRule.get(rule.name), originDate, sessions, asOf),
+  );
+}
+
+// ---- batched loaders (bounded: one query per data source, KTD4) ----
+
+function eventParentColumn(parentType: ServiceParentType) {
+  return parentType === "firearm"
+    ? serviceEvent.firearmId
+    : serviceEvent.accessoryId;
+}
+
+function ruleParentColumn(parentType: ServiceParentType) {
+  return parentType === "firearm"
+    ? serviceRule.firearmId
+    : serviceRule.accessoryId;
+}
+
+/**
+ * Latest `serviced_on` per (item, rule name), grouped over many parent ids
+ * at once (mirrors `loadLastInventoriedBatch`'s batched grouped-`max`
+ * shape, extended with a second group-by column since each rule on an item
+ * measures from its OWN last service point, not the item's overall last
+ * event). An (item, rule) pair with no event is absent from the inner map —
+ * the caller reads that as "measure from origin" (R10).
+ */
+async function loadLastServicePointBatch(
+  tx: DbOrTx,
+  parentType: ServiceParentType,
+  parentIds: string[],
+): Promise<Map<string, Map<string, string>>> {
+  const byItem = new Map<string, Map<string, string>>();
+  if (parentIds.length === 0) return byItem;
+
+  const column = eventParentColumn(parentType);
+  const rows = await tx
+    .select({
+      parentId: column,
+      ruleName: serviceEvent.ruleName,
+      last: max(serviceEvent.servicedOn),
+    })
+    .from(serviceEvent)
+    .where(inArray(column, parentIds))
+    .groupBy(column, serviceEvent.ruleName);
+
+  for (const row of rows) {
+    if (row.parentId === null || row.last === null) continue; // defensive; groupBy never yields this
+    const byRule = byItem.get(row.parentId) ?? new Map<string, string>();
+    byRule.set(row.ruleName, row.last);
+    byItem.set(row.parentId, byRule);
+  }
+  return byItem;
+}
+
+/** Item rule rows for many parents at once, grouped by parent id. */
+async function loadItemRulesBatch(
+  tx: DbOrTx,
+  parentType: ServiceParentType,
+  parentIds: string[],
+): Promise<Map<string, ItemRule[]>> {
+  const byItem = new Map<string, ItemRule[]>();
+  if (parentIds.length === 0) return byItem;
+
+  const column = ruleParentColumn(parentType);
+  const rows = await tx
+    .select()
+    .from(serviceRule)
+    .where(inArray(column, parentIds));
+
+  for (const row of rows) {
+    const parent = resolveParent(row);
+    if (parent === null) continue; // defensive; the exactly-one-parent CHECK guarantees this
+    const rules = byItem.get(parent.parentId) ?? [];
+    rules.push(toItemRule(row));
+    byItem.set(parent.parentId, rules);
+  }
+  return byItem;
+}
+
+function defaultsKey(ownerId: string, category: string): string {
+  return `${ownerId}::${category}`;
+}
+
+/** Every listed owner's default rule set for one scope, grouped by owner+category. */
+async function loadDefaultsForOwnersBatch(
+  tx: DbOrTx,
+  scope: ServiceParentType,
+  ownerIds: string[],
+): Promise<Map<string, DefaultRule[]>> {
+  const byOwnerCategory = new Map<string, DefaultRule[]>();
+  if (ownerIds.length === 0) return byOwnerCategory;
+
+  const rows = await tx
+    .select()
+    .from(serviceRuleDefault)
+    .where(
+      and(
+        eq(serviceRuleDefault.scope, scope),
+        inArray(serviceRuleDefault.ownerId, ownerIds),
+      ),
+    );
+
+  for (const row of rows) {
+    const key = defaultsKey(row.ownerId, row.category);
+    const rules = byOwnerCategory.get(key) ?? [];
+    rules.push(toDefaultRule(row));
+    byOwnerCategory.set(key, rules);
+  }
+  return byOwnerCategory;
+}
+
+/** Range-session rows for many firearms at once, grouped by firearm id. */
+async function loadFirearmSessionsBatch(
+  tx: DbOrTx,
+  firearmIds: string[],
+): Promise<Map<string, SessionRow[]>> {
+  const byFirearm = new Map<string, SessionRow[]>();
+  if (firearmIds.length === 0) return byFirearm;
+
+  const rows = await tx
+    .select({
+      firearmId: rangeSession.firearmId,
+      date: rangeSession.date,
+      roundsFired: rangeSession.roundsFired,
+    })
+    .from(rangeSession)
+    .where(inArray(rangeSession.firearmId, firearmIds));
+
+  for (const row of rows) {
+    const sessions = byFirearm.get(row.firearmId) ?? [];
+    sessions.push({ date: parseISO(row.date), roundsFired: row.roundsFired });
+    byFirearm.set(row.firearmId, sessions);
+  }
+  return byFirearm;
+}
+
+/**
+ * Range-session rows attributable to many accessories at once, grouped by
+ * accessory id — restricted to sessions whose FIREARM is in
+ * `visibleFirearmIds` (R9's security requirement, mirroring
+ * `accessoryRoundsFired`'s join): without that restriction, a remounted
+ * accessory would leak rounds fired on a firearm the actor cannot see. An
+ * accessory whose only mounted sessions belong to an invisible firearm
+ * contributes no rounds — it is simply absent from the returned map.
+ */
+async function loadAccessorySessionsBatch(
+  tx: DbOrTx,
+  accessoryIds: string[],
+  visibleFirearmIds: string[],
+): Promise<Map<string, SessionRow[]>> {
+  const byAccessory = new Map<string, SessionRow[]>();
+  if (accessoryIds.length === 0 || visibleFirearmIds.length === 0) {
+    return byAccessory;
+  }
+
+  const rows = await tx
+    .select({
+      accessoryId: rangeSessionAccessory.accessoryId,
+      date: rangeSession.date,
+      roundsFired: rangeSession.roundsFired,
+    })
+    .from(rangeSessionAccessory)
+    .innerJoin(
+      rangeSession,
+      eq(rangeSessionAccessory.rangeSessionId, rangeSession.id),
+    )
+    .where(
+      and(
+        inArray(rangeSessionAccessory.accessoryId, accessoryIds),
+        inArray(rangeSession.firearmId, visibleFirearmIds),
+      ),
+    );
+
+  for (const row of rows) {
+    if (row.accessoryId === null) continue;
+    const sessions = byAccessory.get(row.accessoryId) ?? [];
+    sessions.push({ date: parseISO(row.date), roundsFired: row.roundsFired });
+    byAccessory.set(row.accessoryId, sessions);
+  }
+  return byAccessory;
+}
+
+// ---- per-item due resolution ----
+
+/**
+ * An item's origin date (KTD9, updated during implementation) — shared by
+ * both firearms and accessories: `acquiredDate` when set, else `createdAt`.
+ * Accessories gained their own `acquiredDate` after the plan's original
+ * scope (see this file's header comment), at which point their resolution
+ * became byte-identical to the firearm one, so both families share this one
+ * function instead of two copies (KISS/DRY).
+ */
+function itemOriginDate(row: {
+  acquiredDate: string | null;
+  createdAt: Date;
+}): Date {
+  return row.acquiredDate !== null ? parseISO(row.acquiredDate) : row.createdAt;
+}
+
+/** `getItemDueState`'s firearm branch — a firearm by its own visibility (R6). */
+async function getFirearmDueState(
+  actorId: string,
+  parentId: string,
+  asOf: Date,
+): Promise<RuleDueState[]> {
+  const { ownerId, category } = await requireFirearmVisible(
+    db,
+    actorId,
+    parentId,
+  );
+  const [defaultRows, itemRuleRows, lastByItem, sessions, [row]] =
+    await Promise.all([
+      loadDefaults(db, ownerId, "firearm", category),
+      loadItemRules(db, "firearm", parentId),
+      loadLastServicePointBatch(db, "firearm", [parentId]),
+      loadFirearmSessionsBatch(db, [parentId]).then(
+        (byFirearm) => byFirearm.get(parentId) ?? [],
+      ),
+      db
+        .select({
+          acquiredDate: firearm.acquiredDate,
+          createdAt: firearm.createdAt,
+        })
+        .from(firearm)
+        .where(eq(firearm.id, parentId))
+        .limit(1),
+    ]);
+  if (!row) return []; // defensive; requireFirearmVisible already confirmed existence
+
+  const resolved = resolveEffectiveRules(
+    defaultRows.map(toDefaultRule),
+    itemRuleRows.map(toItemRule),
+  );
+  const lastByRule = lastByItem.get(parentId) ?? new Map<string, string>();
+  return resolveDueRules(
+    resolved,
+    lastByRule,
+    itemOriginDate(row),
+    sessions,
+    asOf,
+  );
+}
+
+/** `getItemDueState`'s accessory branch — direct ownership only (KTD3). */
+async function getAccessoryDueState(
+  actorId: string,
+  parentId: string,
+  asOf: Date,
+): Promise<RuleDueState[]> {
+  const { ownerId, category } = await requireAccessoryOwner(
+    db,
+    actorId,
+    parentId,
+  );
+  const [defaultRows, itemRuleRows, lastByItem, visibleFirearmIds, [row]] =
+    await Promise.all([
+      loadDefaults(db, ownerId, "accessory", category),
+      loadItemRules(db, "accessory", parentId),
+      loadLastServicePointBatch(db, "accessory", [parentId]),
+      getVisibleIds(db, actorId, "firearm"),
+      db
+        .select({
+          acquiredDate: accessory.acquiredDate,
+          createdAt: accessory.createdAt,
+        })
+        .from(accessory)
+        .where(eq(accessory.id, parentId))
+        .limit(1),
+    ]);
+  if (!row) return []; // defensive; requireAccessoryOwner already confirmed existence
+
+  const sessions = await loadAccessorySessionsBatch(
+    db,
+    [parentId],
+    [...visibleFirearmIds],
+  ).then((byAccessory) => byAccessory.get(parentId) ?? []);
+
+  const resolved = resolveEffectiveRules(
+    defaultRows.map(toDefaultRule),
+    itemRuleRows.map(toItemRule),
+  );
+  const lastByRule = lastByItem.get(parentId) ?? new Map<string, string>();
+  return resolveDueRules(
+    resolved,
+    lastByRule,
+    itemOriginDate(row),
+    sessions,
+    asOf,
+  );
+}
+
+/**
+ * One item's resolved, due-annotated rule set (R7–R10, R12). Authorized the
+ * same way `rules-service.ts` reads are: a firearm by its own visibility
+ * (any of owner/edit/view, R6); an accessory by direct ownership (KTD3).
+ * Defaults are loaded against the ITEM'S OWNER, never the viewer, so a
+ * shared firearm's rules always reflect its owner's configuration (R6).
+ * `asOf` defaults to "now" but is an explicit parameter so callers (and
+ * tests) can pin it.
+ */
+export async function getItemDueState(
+  actorId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+  asOf: Date = new Date(),
+): Promise<RuleDueState[]> {
+  return parentType === "firearm"
+    ? getFirearmDueState(actorId, parentId, asOf)
+    : getAccessoryDueState(actorId, parentId, asOf);
+}
+
+// ---- collection-wide due resolution (bounded query count, KTD4) ----
+
+type FirearmRow = typeof firearm.$inferSelect;
+type AccessoryRow = typeof accessory.$inferSelect;
+
+/** Resolve one firearm's due entry, or `null` when it has no effective rules. */
+function buildFirearmEntry(
+  fa: FirearmRow,
+  defaultsByKey: Map<string, DefaultRule[]>,
+  rulesByItem: Map<string, ItemRule[]>,
+  lastByItem: Map<string, Map<string, string>>,
+  sessionsByItem: Map<string, SessionRow[]>,
+  asOf: Date,
+): ItemDueEntry | null {
+  const defaults = defaultsByKey.get(defaultsKey(fa.ownerId, fa.type)) ?? [];
+  const itemRules = rulesByItem.get(fa.id) ?? [];
+  const resolved = resolveEffectiveRules(defaults, itemRules);
+  if (resolved.length === 0) return null;
+
+  const lastByRule = lastByItem.get(fa.id) ?? new Map<string, string>();
+  const sessions = sessionsByItem.get(fa.id) ?? [];
+  return {
+    parentType: "firearm",
+    parentId: fa.id,
+    rules: resolveDueRules(
+      resolved,
+      lastByRule,
+      itemOriginDate(fa),
+      sessions,
+      asOf,
+    ),
+  };
+}
+
+/** Resolve one accessory's due entry, or `null` when it has no effective rules. */
+function buildAccessoryEntry(
+  acc: AccessoryRow,
+  defaultsByKey: Map<string, DefaultRule[]>,
+  rulesByItem: Map<string, ItemRule[]>,
+  lastByItem: Map<string, Map<string, string>>,
+  sessionsByItem: Map<string, SessionRow[]>,
+  asOf: Date,
+): ItemDueEntry | null {
+  const defaults =
+    defaultsByKey.get(defaultsKey(acc.ownerId, acc.category)) ?? [];
+  const itemRules = rulesByItem.get(acc.id) ?? [];
+  const resolved = resolveEffectiveRules(defaults, itemRules);
+  if (resolved.length === 0) return null;
+
+  const lastByRule = lastByItem.get(acc.id) ?? new Map<string, string>();
+  const sessions = sessionsByItem.get(acc.id) ?? [];
+  return {
+    parentType: "accessory",
+    parentId: acc.id,
+    rules: resolveDueRules(
+      resolved,
+      lastByRule,
+      itemOriginDate(acc),
+      sessions,
+      asOf,
+    ),
+  };
+}
+
+/**
+ * The actor's visible firearms and OWNED (never granted/mounted-inherited)
+ * accessories — see the accessory-scope comment on `listDueForVisibleCollection`.
+ * Accepts an optional `visibleFirearmsAlreadyLoaded` — the same visible-firearm
+ * set a caller (e.g. the firearms list page) has often already fetched for its
+ * own purposes — to skip re-running `listFirearms`'s two round trips
+ * (`getVisibleIds` + select). Falls back to a fresh load when not supplied.
+ */
+async function loadVisibleItems(
+  actorId: string,
+  visibleFirearmsAlreadyLoaded?: FirearmRow[],
+): Promise<{ firearms: FirearmRow[]; accessories: AccessoryRow[] }> {
+  const [firearms, accessories] = await Promise.all([
+    visibleFirearmsAlreadyLoaded ?? listFirearms(actorId),
+    // Deliberately NOT `listAccessories(actorId)` — that returns owned ∪
+    // mounted-on-a-visible-firearm accessories, which would surface a
+    // GRANTEE'S shared firearm's mounted accessory (owned by someone else)
+    // here. Accessory service is owner-only throughout (KTD3), so the
+    // collection-wide accessory scope is `owner_id = actorId`, full stop —
+    // never the broader mount-inheritance visibility the general accessory
+    // list uses.
+    db.select().from(accessory).where(eq(accessory.ownerId, actorId)),
+  ]);
+  return { firearms, accessories };
+}
+
+/** Every batched data source `buildFirearmEntry`/`buildAccessoryEntry` need. */
+interface BatchedDueData {
+  firearmDefaults: Map<string, DefaultRule[]>;
+  accessoryDefaults: Map<string, DefaultRule[]>;
+  firearmRules: Map<string, ItemRule[]>;
+  accessoryRules: Map<string, ItemRule[]>;
+  firearmLast: Map<string, Map<string, string>>;
+  accessoryLast: Map<string, Map<string, string>>;
+  firearmSessions: Map<string, SessionRow[]>;
+  accessorySessions: Map<string, SessionRow[]>;
+}
+
+/** One batched load per data source (KTD4) — never a per-item query. */
+async function loadBatchedDueData(
+  firearms: FirearmRow[],
+  accessories: AccessoryRow[],
+  actorId: string,
+): Promise<BatchedDueData> {
+  const firearmIds = firearms.map((f) => f.id);
+  const accessoryIds = accessories.map((a) => a.id);
+  const firearmOwnerIds = [...new Set(firearms.map((f) => f.ownerId))];
+  // Every accessory here is already scoped to `actorId` (see
+  // `loadVisibleItems`), so there is exactly one accessory owner to load
+  // defaults for.
+  const accessoryOwnerIds = accessories.length > 0 ? [actorId] : [];
+
+  const [
+    firearmDefaults,
+    accessoryDefaults,
+    firearmRules,
+    accessoryRules,
+    firearmLast,
+    accessoryLast,
+    firearmSessions,
+    accessorySessions,
+  ] = await Promise.all([
+    loadDefaultsForOwnersBatch(db, "firearm", firearmOwnerIds),
+    loadDefaultsForOwnersBatch(db, "accessory", accessoryOwnerIds),
+    loadItemRulesBatch(db, "firearm", firearmIds),
+    loadItemRulesBatch(db, "accessory", accessoryIds),
+    loadLastServicePointBatch(db, "firearm", firearmIds),
+    loadLastServicePointBatch(db, "accessory", accessoryIds),
+    loadFirearmSessionsBatch(db, firearmIds),
+    loadAccessorySessionsBatch(db, accessoryIds, firearmIds),
+  ]);
+
+  return {
+    firearmDefaults,
+    accessoryDefaults,
+    firearmRules,
+    accessoryRules,
+    firearmLast,
+    accessoryLast,
+    firearmSessions,
+    accessorySessions,
+  };
+}
+
+const isPresent = (e: ItemDueEntry | null): e is ItemDueEntry => e !== null;
+
+/**
+ * Due state for EVERY item visible to `actorId`, in a bounded number of
+ * queries regardless of how many items are visible (Definition of Done,
+ * U4) — one batched load per data source (owners' defaults, item rules,
+ * last-service-points, session rows), never a per-item query. An owner with
+ * no defaults anywhere and no item-only rules yields an empty array, not an
+ * error (every item resolves zero effective rules and is omitted).
+ *
+ * `visibleFirearmsAlreadyLoaded`, when supplied, is used verbatim as the
+ * visible-firearm set instead of re-running `listFirearms` — see
+ * `loadVisibleItems`. The name is the contract: a caller MUST pass a set
+ * already filtered to the actor's own visible firearms (e.g. `listFirearms(actorId)`'s
+ * result) — never an unfiltered list, which would leak cross-visibility data.
+ */
+export async function listDueForVisibleCollection(
+  actorId: string,
+  asOf: Date = new Date(),
+  visibleFirearmsAlreadyLoaded?: FirearmRow[],
+): Promise<ItemDueEntry[]> {
+  const { firearms, accessories } = await loadVisibleItems(
+    actorId,
+    visibleFirearmsAlreadyLoaded,
+  );
+  if (firearms.length === 0 && accessories.length === 0) return [];
+
+  const {
+    firearmDefaults,
+    accessoryDefaults,
+    firearmRules,
+    accessoryRules,
+    firearmLast,
+    accessoryLast,
+    firearmSessions,
+    accessorySessions,
+  } = await loadBatchedDueData(firearms, accessories, actorId);
+
+  const firearmEntries = firearms
+    .map((fa) =>
+      buildFirearmEntry(
+        fa,
+        firearmDefaults,
+        firearmRules,
+        firearmLast,
+        firearmSessions,
+        asOf,
+      ),
+    )
+    .filter(isPresent);
+  const accessoryEntries = accessories
+    .map((acc) =>
+      buildAccessoryEntry(
+        acc,
+        accessoryDefaults,
+        accessoryRules,
+        accessoryLast,
+        accessorySessions,
+        asOf,
+      ),
+    )
+    .filter(isPresent);
+
+  return [...firearmEntries, ...accessoryEntries];
+}
+
+/**
+ * Parent ids (of one family) with at least one due rule, from
+ * `listDueForVisibleCollection`'s output — the shared filter behind the
+ * firearm and accessory list markers (R20). Firearm and accessory entries
+ * are independent in `entries` (never merged), so an item due only because
+ * of an accessory mounted to it never appears here on the firearm's account
+ * — only the accessory's own entry does.
+ */
+export function dueParentIds(
+  entries: ItemDueEntry[],
+  parentType: ServiceParentType,
+): Set<string> {
+  return new Set(
+    entries
+      .filter(
+        (entry) =>
+          entry.parentType === parentType &&
+          entry.rules.some((rule) => rule.due),
+      )
+      .map((entry) => entry.parentId),
+  );
+}
diff --git a/src/domain/service-intervals/events-service.ts b/src/domain/service-intervals/events-service.ts
new file mode 100644
index 00000000..bc483aff
--- /dev/null
+++ b/src/domain/service-intervals/events-service.ts
@@ -0,0 +1,528 @@
+import { desc, eq, inArray } from "drizzle-orm";
+import { authorizeUpdate } from "@/src/auth/authorize";
+import { NotAuthorizedError, NotFoundError } from "@/src/auth/errors";
+import {
+  type Permission,
+  resolvePermission,
+  visibleFirearmPermissions,
+} from "@/src/auth/visibility";
+import { assertWritesAllowed } from "@/src/backup/maintenance";
+import { type DbOrTx, db } from "@/src/db/client";
+import { accessory, serviceEvent } from "@/src/db/schema";
+import { ValidationError } from "../errors";
+import { MAX_BULK_SERVICE_ITEMS } from "./constants";
+import { resolveEffectiveRules } from "./derive";
+import {
+  loadDefaults,
+  loadItemRules,
+  requireAccessoryOwner,
+  requireFirearmVisible,
+  resolveParent,
+  type ServiceParentType,
+  toDefaultRule,
+  toItemRule,
+} from "./rules-service";
+import {
+  type ServiceEventInput,
+  type ServiceEventUpdateInput,
+  type ServiceEventValidationCode,
+  validateServicedOn,
+  validateServiceEventInput,
+  validateServiceEventUpdateInput,
+} from "./validate-event";
+
+export type {
+  ServiceEventInput,
+  ServiceEventUpdateInput,
+  ServiceEventValidationCode,
+};
+
+/**
+ * Service-events layer (service-intervals plan, U4). Logging one event, the
+ * R16 bulk mark-serviced path, and service history reads. Nothing here
+ * decides due state (that's `due-service.ts`) — this file only ever writes
+ * and reads `service_event` rows.
+ *
+ * Authorization mirrors `rules-service.ts`'s split (KTD3), but for WRITES
+ * only, and deliberately looser on firearms than rule configuration: logging
+ * a firearm service event takes `authorizeUpdate` (an edit-grantee may log
+ * service — this is exactly what the now-retired `cleaned`/`lubed` inventory
+ * log entries permitted via `authorizeUpdate` in `inventory-log/service.ts`,
+ * so U5's conversion preserved capability an edit-grantee already had rather
+ * than silently revoking it). Accessory
+ * events are owner-only throughout (accessories have no `authorize.ts` gate
+ * and are never a grant `ParentType`). `actorId` is always the parameter the
+ * caller authorized with — never a separate, caller-suppliable field on the
+ * input — so an event can never be logged in anyone's name but the actor's.
+ *
+ * The bulk path (R16) is a convenience over the single path, not a
+ * higher-privilege one: it authorizes every item in the batch with the exact
+ * same per-family rule as `logServiceEvent`, inside one transaction, so a
+ * single unauthorized pair rolls the whole batch back and writes nothing.
+ */
+
+export type ServiceEventRow = typeof serviceEvent.$inferSelect;
+
+/**
+ * Authorize an event WRITE for one item, per family (KTD3): firearms accept
+ * an edit grant (`authorizeUpdate`); accessories are owner-only, resolved
+ * directly since they have no `authorize.ts` gate and never route through
+ * the mounted-firearm visibility inheritance (that inheritance is for
+ * viewing/using the accessory, not for configuring or logging service
+ * against it).
+ */
+async function authorizeEventWrite(
+  tx: DbOrTx,
+  actorId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+): Promise<void> {
+  if (parentType === "firearm") {
+    await authorizeUpdate(tx, actorId, "firearm", parentId);
+    return;
+  }
+  await assertWritesAllowed(tx);
+  const [row] = await tx
+    .select({ ownerId: accessory.ownerId })
+    .from(accessory)
+    .where(eq(accessory.id, parentId))
+    .limit(1);
+  if (!row || row.ownerId !== actorId) throw new NotFoundError();
+}
+
+/**
+ * Batched counterpart to `authorizeEventWrite`, used by the bulk mark-
+ * serviced path (R16). Produces the EXACT SAME per-item authorization
+ * outcome as calling `authorizeEventWrite` in a loop — same error type
+ * (`NotAuthorizedError` for a firearm view-grantee, `NotFoundError` for
+ * anything outside the actor's visible set, same as a stranger's item or a
+ * non-owned accessory) — but in a bounded number of queries regardless of
+ * batch size: one `visibleFirearmPermissions` call covers every firearm
+ * pair, and one `IN` query covers every accessory pair, instead of one query
+ * per item. `assertWritesAllowed` runs once up front rather than once per
+ * item, which is safe: maintenance mode can't toggle mid-transaction.
+ */
+async function authorizeEventWritesBatch(
+  tx: DbOrTx,
+  actorId: string,
+  items: BulkServiceItem[],
+): Promise<void> {
+  await assertWritesAllowed(tx);
+
+  const firearmIds = [
+    ...new Set(
+      items
+        .filter((item) => item.parentType === "firearm")
+        .map((item) => item.parentId),
+    ),
+  ];
+  const accessoryIds = [
+    ...new Set(
+      items
+        .filter((item) => item.parentType === "accessory")
+        .map((item) => item.parentId),
+    ),
+  ];
+
+  const firearmPermissions: Map<string, Permission> =
+    firearmIds.length > 0
+      ? await visibleFirearmPermissions(tx, actorId)
+      : new Map();
+
+  const accessoryOwners = new Map<string, string>();
+  if (accessoryIds.length > 0) {
+    const rows = await tx
+      .select({ id: accessory.id, ownerId: accessory.ownerId })
+      .from(accessory)
+      .where(inArray(accessory.id, accessoryIds));
+    for (const row of rows) accessoryOwners.set(row.id, row.ownerId);
+  }
+
+  for (const item of items) {
+    if (item.parentType === "firearm") {
+      const perm = firearmPermissions.get(item.parentId) ?? null;
+      if (perm === "owner" || perm === "edit") continue;
+      if (perm === "view") {
+        throw new NotAuthorizedError(
+          "read-only access; cannot modify this item",
+        );
+      }
+      throw new NotFoundError();
+    } else {
+      const ownerId = accessoryOwners.get(item.parentId);
+      if (ownerId === undefined || ownerId !== actorId) {
+        throw new NotFoundError();
+      }
+    }
+  }
+}
+
+function parentColumns(parentType: ServiceParentType, parentId: string) {
+  return {
+    firearmId: parentType === "firearm" ? parentId : null,
+    accessoryId: parentType === "accessory" ? parentId : null,
+  };
+}
+
+/**
+ * An item's current effective rule names — its own item rules plus its
+ * owner's category defaults for the item's category (R4, R5), reusing
+ * `rules-service.ts`'s single-item resolution helpers and `derive.ts`'s
+ * `resolveEffectiveRules` (DRY, mirroring `due-service.ts`'s per-item shape).
+ * Backs the F2 fix below: a `ruleName` a caller submits is only ever
+ * trustworthy when it is re-checked against what the item actually carries
+ * NOW, not what it carried when a form rendered.
+ *
+ * Queries here run SEQUENTIALLY, not via `Promise.all` — `tx` is a single
+ * connection bound to one open transaction, so issuing two queries against
+ * it concurrently races on that one connection (node-postgres deprecates
+ * this: "Calling client.query() when the client is already executing a
+ * query"). `due-service.ts`'s batched loaders can run concurrently because
+ * each one there queries the pool-level `db`, which hands out a separate
+ * connection per call; that shape doesn't apply inside a transaction.
+ */
+async function loadEffectiveRuleNames(
+  tx: DbOrTx,
+  actorId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+): Promise<Set<string>> {
+  const { ownerId, category } =
+    parentType === "firearm"
+      ? await requireFirearmVisible(tx, actorId, parentId)
+      : await requireAccessoryOwner(tx, actorId, parentId);
+  const defaultRows = await loadDefaults(tx, ownerId, parentType, category);
+  const itemRuleRows = await loadItemRules(tx, parentType, parentId);
+  const resolved = resolveEffectiveRules(
+    defaultRows.map(toDefaultRule),
+    itemRuleRows.map(toItemRule),
+  );
+  return new Set(resolved.map((rule) => rule.name));
+}
+
+/**
+ * Confirm `ruleName` resolves against `parentId`'s current effective rule
+ * set (F2 fix). The `/summary` bulk checklist captures `ruleName` at render
+ * time; if the rule was renamed on this item between render and submit, the
+ * old name no longer resolves, and inserting a `service_event` under it
+ * anyway would land under a dead name — `loadLastServicePointBatch` groups
+ * strictly by exact name, so due state would silently never advance and the
+ * owner would get no error at all. Rejecting here, inside the same
+ * transaction as the write, closes that window.
+ */
+async function assertRuleExists(
+  tx: DbOrTx,
+  actorId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+  ruleName: string,
+): Promise<void> {
+  const names = await loadEffectiveRuleNames(tx, actorId, parentType, parentId);
+  if (!names.has(ruleName)) {
+    throw new ValidationError(["ruleNotFound"]);
+  }
+}
+
+/**
+ * Batched counterpart to `assertRuleExists`, for the bulk path. Resolves
+ * effective rule names ONCE PER UNIQUE (parentType, parentId) pair in the
+ * batch, not once per item — a duplicate item+rule pair (F8) or several rows
+ * against the same item costs one lookup, not several. `MAX_BULK_SERVICE_ITEMS`
+ * (F6) bounds the batch to a few hundred, so this per-unique-item shape is
+ * proportionate here; it is not `due-service.ts`'s fully batched,
+ * one-query-per-data-source shape, which exists for the much larger
+ * visible-collection READ path (KTD4).
+ *
+ * Lookups run SEQUENTIALLY (a `for...of` with `await`, not `Promise.all`) —
+ * see `loadEffectiveRuleNames`'s doc: `tx` is one connection, and this whole
+ * batch shares it.
+ */
+async function assertRuleNamesResolveBulk(
+  tx: DbOrTx,
+  actorId: string,
+  items: BulkServiceItem[],
+): Promise<void> {
+  const uniqueParents = new Map<
+    string,
+    { parentType: ServiceParentType; parentId: string }
+  >();
+  for (const item of items) {
+    uniqueParents.set(`${item.parentType}:${item.parentId}`, item);
+  }
+
+  const namesByParent = new Map<string, Set<string>>();
+  for (const [key, { parentType, parentId }] of uniqueParents) {
+    namesByParent.set(
+      key,
+      await loadEffectiveRuleNames(tx, actorId, parentType, parentId),
+    );
+  }
+
+  for (const item of items) {
+    const key = `${item.parentType}:${item.parentId}`;
+    const names = namesByParent.get(key);
+    if (!names?.has(item.ruleName.trim())) {
+      throw new ValidationError(["ruleNotFound"]);
+    }
+  }
+}
+
+/**
+ * Log one service event against a rule (R14). `actorId` is always the
+ * acting user (never caller-supplied) and is authorized before any write.
+ */
+export async function logServiceEvent(
+  actorId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+  input: ServiceEventInput,
+): Promise<ServiceEventRow> {
+  const codes = validateServiceEventInput(input);
+  if (codes.length > 0) throw new ValidationError(codes);
+
+  const ruleName = input.ruleName.trim();
+  const servicedOn = input.servicedOn.trim();
+
+  return db.transaction(async (tx) => {
+    await authorizeEventWrite(tx, actorId, parentType, parentId);
+    await assertRuleExists(tx, actorId, parentType, parentId, ruleName);
+    const [row] = await tx
+      .insert(serviceEvent)
+      .values({
+        ...parentColumns(parentType, parentId),
+        ruleName,
+        servicedOn,
+        actorId,
+        notes: input.notes ?? "",
+      })
+      .returning();
+    return row;
+  });
+}
+
+/** One item-and-rule pair to mark serviced in a bulk call (R16). */
+export interface BulkServiceItem {
+  parentType: ServiceParentType;
+  parentId: string;
+  ruleName: string;
+}
+
+export interface BulkServiceInput {
+  items: BulkServiceItem[];
+  servicedOn: string;
+  notes?: string;
+}
+
+/**
+ * Mark one or many item-and-rule pairs serviced as of one date, in a single
+ * transaction (R16). Authorizes every pair with the same per-family rule
+ * `logServiceEvent` uses; any single unauthorized (or missing) pair throws
+ * and rolls the whole batch back, so the batch either writes every event or
+ * writes none. An empty `items` list writes nothing and returns `[]` without
+ * touching the database. Rejects a batch over `MAX_BULK_SERVICE_ITEMS` (F6)
+ * before any DB work at all, and rejects any pair whose `ruleName` no longer
+ * resolves against that item's current effective rule set (F2) inside the
+ * same transaction as the writes.
+ */
+export async function logServiceEventsBulk(
+  actorId: string,
+  input: BulkServiceInput,
+): Promise<ServiceEventRow[]> {
+  const { items, notes = "" } = input;
+  if (items.length === 0) return [];
+  if (items.length > MAX_BULK_SERVICE_ITEMS) {
+    throw new ValidationError(["bulkTooLarge"]);
+  }
+
+  const servicedOn = input.servicedOn.trim();
+  const codes: ServiceEventValidationCode[] = [
+    ...validateServicedOn(servicedOn),
+  ];
+  if (items.some((item) => item.ruleName.trim() === "")) {
+    codes.push("emptyRuleName");
+  }
+  if (codes.length > 0) throw new ValidationError(codes);
+
+  return db.transaction(async (tx) => {
+    await authorizeEventWritesBatch(tx, actorId, items);
+    await assertRuleNamesResolveBulk(tx, actorId, items);
+    return tx
+      .insert(serviceEvent)
+      .values(
+        items.map((item) => ({
+          ...parentColumns(item.parentType, item.parentId),
+          ruleName: item.ruleName.trim(),
+          servicedOn,
+          actorId,
+          notes,
+        })),
+      )
+      .returning();
+  });
+}
+
+/**
+ * Resolve which parent family and id a `service_event` row belongs to,
+ * straight off the row itself — `service_event`'s exactly-one-parent CHECK
+ * (KTD2) guarantees exactly one of these is non-null for a real row.
+ * Exported so `service-actions.ts` can revalidate the correct detail route
+ * after an edit or delete using only the row the domain layer handed back,
+ * never a parent the client would otherwise have to supply and be trusted.
+ */
+export function resolveServiceEventParent(
+  row: Pick<ServiceEventRow, "firearmId" | "accessoryId">,
+): { parentType: ServiceParentType; parentId: string } {
+  const parent = resolveParent(row);
+  if (parent !== null) return parent;
+  // Defensive only — the DB's exactly-one-parent CHECK guarantees a real row
+  // never reaches here. Not found is the safest response to an impossible
+  // row shape: it reveals nothing and matches every other "can't resolve
+  // this event" outcome in this file.
+  throw new NotFoundError();
+}
+
+/**
+ * Correct an existing service event's `servicedOn` and/or `notes` — the
+ * correction path this unit adds. Before this, `events-service.ts` exported
+ * only `logServiceEvent`/`logServiceEventsBulk`/`listServiceHistory`: once an
+ * event was written, a mis-logged date had no in-app fix, and because due
+ * state is `MAX(serviced_on)` grouped by (item, rule_name) with nothing else
+ * stored (KD5), that one bad row silently skewed the rule's due state
+ * forever.
+ *
+ * `ruleName` and the parent are deliberately NOT accepted here — only
+ * `ServicedOn`/`notes` may change (see `ServiceEventUpdateInput`'s doc).
+ * Letting an edit move an event to a different rule or a different item
+ * would let one write silently rewrite TWO rules' derived due state at once
+ * (the old rule loses an entry from its `MAX`, the new one gains one) with
+ * no signal that either happened. Renaming a rule (`updateItemRule` in
+ * `rules-service.ts`, which re-points its events in the same transaction,
+ * KTD1) and re-logging a fresh event under the correct rule are the
+ * supported paths for those cases.
+ *
+ * The parent is resolved from the ROW ITSELF (`resolveServiceEventParent`),
+ * never from a caller-supplied value — an event id is the only trustworthy
+ * handle a caller has on an existing event. Authorization is the EXACT SAME
+ * per-family check `logServiceEvent` uses (`authorizeEventWrite`, KTD3): an
+ * edit-grantee may correct an event on a shared firearm; accessories are
+ * owner-only throughout. An event outside the actor's visible set raises
+ * `NotFoundError`, never a permission error — the same "not-owner and
+ * not-found are indistinguishable" shape every accessory path in this file
+ * already follows.
+ */
+export async function updateServiceEvent(
+  actorId: string,
+  eventId: string,
+  input: ServiceEventUpdateInput,
+): Promise<ServiceEventRow> {
+  const codes = validateServiceEventUpdateInput(input);
+  if (codes.length > 0) throw new ValidationError(codes);
+  const servicedOn = input.servicedOn.trim();
+
+  return db.transaction(async (tx) => {
+    const [existing] = await tx
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.id, eventId))
+      .limit(1);
+    if (!existing) throw new NotFoundError();
+
+    const { parentType, parentId } = resolveServiceEventParent(existing);
+    await authorizeEventWrite(tx, actorId, parentType, parentId);
+
+    const [row] = await tx
+      .update(serviceEvent)
+      .set({ servicedOn, notes: input.notes ?? "" })
+      .where(eq(serviceEvent.id, eventId))
+      .returning();
+    if (!row) throw new NotFoundError();
+    return row;
+  });
+}
+
+/**
+ * Delete a service event outright — the other half of the correction path.
+ * Because due state is derived on read from `MAX(serviced_on)` per (item,
+ * rule_name) with nothing stored (KD5), deleting the newest event for a rule
+ * needs no special-case handling here at all: the very next read
+ * (`due-service.ts`'s `loadLastServicePointBatch`, a grouped `max` over
+ * whatever rows remain) simply finds the next-newest remaining event for
+ * that name, or finds none and falls back to the item's origin date (R10).
+ * Nothing is recomputed or cascaded by this function — that is the entire
+ * point of nothing being stored.
+ *
+ * Same authorization and parent-resolution shape as `updateServiceEvent`:
+ * the parent is read off the row, never supplied by the caller, and
+ * `authorizeEventWrite` enforces the same per-family split `logServiceEvent`
+ * uses. Returns the now-deleted row (not `void`) so a caller that only ever
+ * had an `eventId` to begin with — `service-actions.ts`'s delete action —
+ * can still learn which detail route to revalidate via
+ * `resolveServiceEventParent`, without the client supplying (and this layer
+ * having to trust) a parent of its own.
+ */
+export async function deleteServiceEvent(
+  actorId: string,
+  eventId: string,
+): Promise<ServiceEventRow> {
+  return db.transaction(async (tx) => {
+    const [existing] = await tx
+      .select()
+      .from(serviceEvent)
+      .where(eq(serviceEvent.id, eventId))
+      .limit(1);
+    if (!existing) throw new NotFoundError();
+
+    const { parentType, parentId } = resolveServiceEventParent(existing);
+    await authorizeEventWrite(tx, actorId, parentType, parentId);
+
+    await tx.delete(serviceEvent).where(eq(serviceEvent.id, eventId));
+    return existing;
+  });
+}
+
+/**
+ * Assert visibility (firearm, any permission) or ownership (accessory,
+ * KTD3) so history reads never reveal existence of an unseen item.
+ */
+async function assertHistoryReadable(
+  actorId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+): Promise<void> {
+  if (parentType === "firearm") {
+    const perm = await resolvePermission(db, actorId, "firearm", parentId);
+    if (perm === null) throw new NotFoundError();
+    return;
+  }
+  const [row] = await db
+    .select({ ownerId: accessory.ownerId })
+    .from(accessory)
+    .where(eq(accessory.id, parentId))
+    .limit(1);
+  if (!row || row.ownerId !== actorId) throw new NotFoundError();
+}
+
+/**
+ * An item's service history, newest first (R17): ordered by `serviced_on`
+ * desc, then `created_at` desc so several rules logged on one day still
+ * sort in a stable order. A firearm's history is readable by any
+ * visibility level (owner/edit/view, KTD3); an accessory's is owner-only.
+ */
+export async function listServiceHistory(
+  actorId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+): Promise<ServiceEventRow[]> {
+  await assertHistoryReadable(actorId, parentType, parentId);
+
+  const parentWhere =
+    parentType === "firearm"
+      ? eq(serviceEvent.firearmId, parentId)
+      : eq(serviceEvent.accessoryId, parentId);
+
+  return db
+    .select()
+    .from(serviceEvent)
+    .where(parentWhere)
+    .orderBy(desc(serviceEvent.servicedOn), desc(serviceEvent.createdAt));
+}
diff --git a/src/domain/service-intervals/rules-service.ts b/src/domain/service-intervals/rules-service.ts
new file mode 100644
index 00000000..8cf22f88
--- /dev/null
+++ b/src/domain/service-intervals/rules-service.ts
@@ -0,0 +1,939 @@
+import { and, asc, count, eq, inArray } from "drizzle-orm";
+import { authorizeOwnerOnlyUpdate } from "@/src/auth/authorize";
+import { NotFoundError } from "@/src/auth/errors";
+import { resolvePermission } from "@/src/auth/visibility";
+import { assertWritesAllowed } from "@/src/backup/maintenance";
+import { type DbOrTx, db } from "@/src/db/client";
+import {
+  accessory,
+  firearm,
+  serviceEvent,
+  serviceRule,
+  serviceRuleDefault,
+} from "@/src/db/schema";
+import { ValidationError } from "../errors";
+import type { DefaultRule, ItemRule } from "./derive";
+import { validateServiceRuleSet } from "./validate";
+
+/**
+ * Defaults and item-rule service layer (service-intervals plan, U3). Owns
+ * category-default CRUD, per-item rule CRUD (override/suppress/item-only,
+ * R5), and the owner's distinct accessory-category listing (KTD8).
+ *
+ * Authorization splits by parent family (KTD3):
+ * - Defaults are owner-scoped with no grant path at all — every read and
+ *   write filters on `owner_id = actorId` directly; there is no visibility
+ *   layer to route through.
+ * - A firearm's item-rule WRITES require `authorizeOwnerOnlyUpdate` — an
+ *   edit-grantee may log service (U4) but may not configure what the owner is
+ *   prompted about. Firearm item-rule READS resolve through the firearm's own
+ *   visibility (`resolvePermission`) so a view-grantee can see a shared
+ *   firearm's resolved rules, `NotFoundError` for an unseen firearm so
+ *   existence is never revealed.
+ * - Accessories have no `authorize.ts` gate at all (not a grant
+ *   `ParentType`). Every accessory read and write here checks
+ *   `accessory.ownerId === actorId` directly and NEVER calls
+ *   `resolveAccessoryPermission` — that function inherits permission from the
+ *   mounted firearm, which would hand a firearm grantee configuration KTD3
+ *   reserves to the accessory's own owner. Not-owner and not-found are
+ *   deliberately indistinguishable here (`NotFoundError` either way).
+ *
+ * Renaming an item rule re-points that item's `service_event` rows carrying
+ * the old `rule_name` in the same transaction (KTD1's trade-off), and a
+ * rename onto a name the item already uses is rejected with the existing
+ * duplicate-name `ValidationError` BEFORE any write, so the DB's unique
+ * constraint is never what surfaces the error.
+ *
+ * Renaming a CATEGORY DEFAULT applies the same precedent one level up
+ * (`updateServiceRuleDefault`'s `repointDefaultRename`): every one of the
+ * owner's own items in that exact scope+category that carries the old name —
+ * whether inheriting (only `service_event` rows) or overriding/suppressing
+ * (its own `service_rule` row too) — moves to the new name in the same
+ * transaction, so no item's service history is silently stranded on a name
+ * nothing measures from any more. See that function's doc for why a
+ * genuinely item-only rule can never be caught up in this rename.
+ */
+
+export type ServiceParentType = "firearm" | "accessory";
+/** A default set's scope uses the same two values as an item's parent family. */
+export type ServiceScope = ServiceParentType;
+
+export type ServiceRuleDefaultRow = typeof serviceRuleDefault.$inferSelect;
+export type ServiceRuleRow = typeof serviceRule.$inferSelect;
+
+export interface ServiceRuleDefaultInput {
+  scope: ServiceScope;
+  category: string;
+  name: string;
+  intervalDays?: number | null;
+  intervalSessions?: number | null;
+  intervalRounds?: number | null;
+}
+
+export type ServiceRuleDefaultUpdateInput = Omit<
+  ServiceRuleDefaultInput,
+  "scope" | "category"
+>;
+
+export interface ItemRuleInput {
+  name: string;
+  suppressed?: boolean;
+  intervalDays?: number | null;
+  intervalSessions?: number | null;
+  intervalRounds?: number | null;
+}
+
+// ---- row <-> pure-domain-shape mapping (U2's `derive.ts` types) ----
+// Exported so U4's `due-service.ts` maps rows the same way rather than
+// re-deriving this shape a second time (DRY).
+
+export function toDefaultRule(row: ServiceRuleDefaultRow): DefaultRule {
+  return {
+    name: row.name,
+    intervalDays: row.intervalDays,
+    intervalSessions: row.intervalSessions,
+    intervalRounds: row.intervalRounds,
+  };
+}
+
+export function toItemRule(row: ServiceRuleRow): ItemRule {
+  return {
+    name: row.name,
+    suppressed: row.suppressed,
+    intervalDays: row.intervalDays,
+    intervalSessions: row.intervalSessions,
+    intervalRounds: row.intervalRounds,
+  };
+}
+
+// ---- shared loaders ----
+// `loadDefaults` and `loadItemRules` are exported for reuse by U4's
+// `due-service.ts`, whose per-item due lookup needs exactly the same
+// owner+scope+category / parent-scoped queries this file already defines
+// (DRY) — the batched, collection-wide loaders due-service also needs are
+// new (KTD4: bounded query count over the whole visible set), so only the
+// single-item shape is shared here.
+
+export async function loadDefaults(
+  tx: DbOrTx,
+  ownerId: string,
+  scope: ServiceScope,
+  category: string,
+): Promise<ServiceRuleDefaultRow[]> {
+  return tx
+    .select()
+    .from(serviceRuleDefault)
+    .where(
+      and(
+        eq(serviceRuleDefault.ownerId, ownerId),
+        eq(serviceRuleDefault.scope, scope),
+        eq(serviceRuleDefault.category, category),
+      ),
+    )
+    .orderBy(asc(serviceRuleDefault.name));
+}
+
+function itemRuleParentWhere(parentType: ServiceParentType, parentId: string) {
+  return parentType === "firearm"
+    ? eq(serviceRule.firearmId, parentId)
+    : eq(serviceRule.accessoryId, parentId);
+}
+
+export async function loadItemRules(
+  tx: DbOrTx,
+  parentType: ServiceParentType,
+  parentId: string,
+): Promise<ServiceRuleRow[]> {
+  return tx
+    .select()
+    .from(serviceRule)
+    .where(itemRuleParentWhere(parentType, parentId))
+    .orderBy(asc(serviceRule.name));
+}
+
+/** A row's resolved parent family + id, off the shared two-nullable-FK shape. */
+export type ResolvedParent =
+  | { parentType: "firearm"; parentId: string }
+  | { parentType: "accessory"; parentId: string };
+
+/**
+ * Resolve which parent family and id a `service_rule`/`service_event` row
+ * belongs to, straight off its `{ firearmId, accessoryId }` shape — the
+ * single shared implementation behind three call sites that previously each
+ * re-derived this independently: `belongsToParent` below,
+ * `resolveServiceEventParent` (`events-service.ts`), and
+ * `loadItemRulesBatch`'s per-row extraction (`due-service.ts`). Exported for
+ * that reuse, alongside `toDefaultRule`/`toItemRule` (same precedent: shared
+ * row<->domain helpers live here).
+ *
+ * Returns `null` for a row with neither FK set — a shape `num_nonnulls(firearm_id,
+ * accessory_id) = 1` (KTD2) forbids for any real row, so this never happens
+ * in practice. Deliberately NOT the caller's decision baked in here: each
+ * call site's existing response to that impossible case differs (a thrown
+ * `NotFoundError`, a `false`, a skipped row), so this helper only resolves
+ * the parent and leaves that response to the caller.
+ */
+export function resolveParent(row: {
+  firearmId: string | null;
+  accessoryId: string | null;
+}): ResolvedParent | null {
+  if (row.firearmId !== null) {
+    return { parentType: "firearm", parentId: row.firearmId };
+  }
+  if (row.accessoryId !== null) {
+    return { parentType: "accessory", parentId: row.accessoryId };
+  }
+  return null;
+}
+
+function belongsToParent(
+  row: Pick<ServiceRuleRow, "firearmId" | "accessoryId">,
+  parentType: ServiceParentType,
+  parentId: string,
+): boolean {
+  const parent = resolveParent(row);
+  return (
+    parent !== null &&
+    parent.parentType === parentType &&
+    parent.parentId === parentId
+  );
+}
+
+/**
+ * Shared duplicate-name guard for defaults and item rules alike (R2):
+ * `excludeId` omitted means "creating new" (nothing to exclude); passing the
+ * row's own id on an update lets it keep its current name. Thrown before any
+ * write, so the DB's unique constraint is never what surfaces the error.
+ *
+ * This is a fast-path pre-check only, not the sole guarantee against a
+ * duplicate name: under READ COMMITTED, two concurrent writes (e.g. a double
+ * submit) can both pass this check and both reach the insert/update below.
+ * `isUniqueNameViolation` + the try/catch in each write function is the
+ * backstop that catches that race at the DB's unique constraints
+ * (`service_rule_default_owner_scope_category_name_unique`,
+ * `service_rule_firearm_name_unique`, `service_rule_accessory_name_unique` —
+ * `src/db/migrations/0019_perfect_nebula.sql`) and maps the loser to the same
+ * clean `ValidationError(["duplicateName"])` this pre-check produces, instead
+ * of letting the raw Postgres driver error (SQLSTATE `23505`) escape.
+ */
+function assertNameAvailable(
+  siblings: Array<{ id: string; name: string }>,
+  name: string,
+  excludeId?: string,
+): void {
+  if (siblings.some((s) => s.id !== excludeId && s.name === name)) {
+    throw new ValidationError(["duplicateName"]);
+  }
+}
+
+/** Postgres SQLSTATE for "unique_violation". */
+const POSTGRES_UNIQUE_VIOLATION = "23505";
+
+function hasUniqueViolationCode(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { code?: unknown }).code === POSTGRES_UNIQUE_VIOLATION
+  );
+}
+
+/**
+ * True when `error` is the `pg` driver's unique-constraint-violation error
+ * (`.code === "23505"`, the Postgres SQLSTATE) — the race-condition backstop
+ * behind `assertNameAvailable`'s pre-check (see that function's doc). Only
+ * matches this specific code so every other DB error still propagates
+ * unchanged; a caller that wants to also confirm WHICH constraint fired can
+ * read `.constraint` off the same error object (also set by `pg` on a
+ * unique-violation), but the four call sites here don't need to distinguish
+ * between the three service-rule unique constraints — all three mean the
+ * same thing to the caller: this name is already taken.
+ *
+ * Checks `error.cause` too: drizzle's `db.transaction`/query layer wraps the
+ * raw `pg` driver error in its own `DrizzleQueryError`, with the original
+ * error (carrying `.code`) as `.cause` — the write functions here would never
+ * see the bare `pg` error directly.
+ */
+function isUniqueNameViolation(error: unknown): boolean {
+  if (hasUniqueViolationCode(error)) return true;
+  const cause = (error as { cause?: unknown } | null)?.cause;
+  return hasUniqueViolationCode(cause);
+}
+
+/**
+ * Resolve a firearm's owner and category (its `type`) for defaults lookup,
+ * authorized through the firearm's own visibility (R6) so a view-grantee can
+ * READ a shared firearm's rules. `NotFoundError` for an unseen firearm.
+ * Exported for reuse by U4's `due-service.ts` (per-item due lookup needs the
+ * exact same owner+category resolution, gated the same way).
+ */
+export async function requireFirearmVisible(
+  tx: DbOrTx,
+  actorId: string,
+  firearmId: string,
+): Promise<{ ownerId: string; category: string }> {
+  const perm = await resolvePermission(tx, actorId, "firearm", firearmId);
+  if (perm === null) throw new NotFoundError();
+  const [row] = await tx
+    .select({ ownerId: firearm.ownerId, type: firearm.type })
+    .from(firearm)
+    .where(eq(firearm.id, firearmId))
+    .limit(1);
+  if (!row) throw new NotFoundError();
+  return { ownerId: row.ownerId, category: row.type };
+}
+
+/**
+ * Resolve an accessory's owner and category directly by ownership. Per KTD3,
+ * accessory rules and history never route through the mounted-firearm
+ * visibility path (`resolveAccessoryPermission`), so a firearm grantee can
+ * never see or touch configuration reserved to the accessory's own owner.
+ * Not-owner and not-found are deliberately indistinguishable — this path
+ * intentionally never consults the visibility layer that would tell them
+ * apart. Exported for reuse by U4's `due-service.ts` (same accessory
+ * owner-only resolution, KTD3).
+ */
+export async function requireAccessoryOwner(
+  tx: DbOrTx,
+  actorId: string,
+  accessoryId: string,
+): Promise<{ ownerId: string; category: string }> {
+  const [row] = await tx
+    .select({ ownerId: accessory.ownerId, category: accessory.category })
+    .from(accessory)
+    .where(eq(accessory.id, accessoryId))
+    .limit(1);
+  if (!row || row.ownerId !== actorId) throw new NotFoundError();
+  return row;
+}
+
+/**
+ * Authorize an item-rule WRITE (create/update/delete) per KTD3: firearms take
+ * `authorizeOwnerOnlyUpdate` (owner-only; an edit-grantee is forbidden, not
+ * merely unseen); accessories resolve ownership directly since they have no
+ * `authorize.ts` gate — `assertWritesAllowed` is called explicitly here since
+ * accessories don't route through `authorizeUpdate`'s built-in check.
+ */
+async function authorizeItemRuleWrite(
+  tx: DbOrTx,
+  actorId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+): Promise<void> {
+  if (parentType === "firearm") {
+    await authorizeOwnerOnlyUpdate(tx, actorId, "firearm", parentId);
+    return;
+  }
+  await assertWritesAllowed(tx);
+  await requireAccessoryOwner(tx, actorId, parentId);
+}
+
+async function repointServiceEvents(
+  tx: DbOrTx,
+  parentType: ServiceParentType,
+  parentId: string,
+  oldName: string,
+  newName: string,
+): Promise<void> {
+  const parentWhere =
+    parentType === "firearm"
+      ? eq(serviceEvent.firearmId, parentId)
+      : eq(serviceEvent.accessoryId, parentId);
+  await tx
+    .update(serviceEvent)
+    .set({ ruleName: newName })
+    .where(and(parentWhere, eq(serviceEvent.ruleName, oldName)));
+}
+
+/**
+ * This owner's own item ids in one scope+category (KTD3: strictly the
+ * owner's own items, in the exact category the default row itself carries —
+ * a firearm's `type` or an accessory's `category`, never a fuzzy match).
+ * Shared by `repointDefaultRename` below, since both halves of that repoint
+ * (item-rule rows and service-event rows) key off the same item set.
+ */
+async function loadCategoryItemIds(
+  tx: DbOrTx,
+  ownerId: string,
+  scope: ServiceScope,
+  category: string,
+): Promise<string[]> {
+  if (scope === "firearm") {
+    const rows = await tx
+      .select({ id: firearm.id })
+      .from(firearm)
+      .where(and(eq(firearm.ownerId, ownerId), eq(firearm.type, category)));
+    return rows.map((row) => row.id);
+  }
+  const rows = await tx
+    .select({ id: accessory.id })
+    .from(accessory)
+    .where(
+      and(eq(accessory.ownerId, ownerId), eq(accessory.category, category)),
+    );
+  return rows.map((row) => row.id);
+}
+
+/**
+ * Repoint every dependent row a category-default rename would otherwise
+ * strand — the same bug class `updateItemRule`'s `repointServiceEvents`
+ * above already fixes for an item-level rename, applied one level up (PR #99
+ * review, P2): everything here is keyed by rule NAME (KTD1), so renaming a
+ * default silently orphaned the service history of every item inheriting or
+ * overriding it, which then reappeared under the new name with no history,
+ * measuring from the item's origin date again.
+ *
+ * - An item that INHERITS this default (no `service_rule` row of its own)
+ *   has only `service_event` rows named `oldName` to repoint.
+ * - An item that OVERRIDES or SUPPRESSES this default carries `oldName` on
+ *   its own `service_rule` row too — that row moves to `newName` alongside
+ *   its `service_event` rows, so the override/suppression keeps applying to
+ *   the renamed default instead of silently reverting to "inherited" under a
+ *   name nothing measures any more.
+ * - A GENUINELY item-only rule (one no default in this category names) can
+ *   never be caught up in this rename despite sharing `oldName`, so there is
+ *   no ambiguous case to special-case here: `resolveEffectiveRules`
+ *   (`derive.ts`) matches an item's own `service_rule` row to a default BY
+ *   NAME ALONE, against that item's own category's default set. This
+ *   function only ever touches items in the SAME owner + SAME scope+category
+ *   as the default being renamed — so any `service_rule` row it finds named
+ *   `oldName` is, by that identical name-matching logic, ALREADY being
+ *   resolved as an override or a suppression of exactly this default, never
+ *   as item-only. An item-only rule is by definition one no default defines;
+ *   a default of this exact name already existing in this exact category is
+ *   what rules out the item-only reading for every row this function could
+ *   possibly touch. Every matching `service_rule` row here is therefore an
+ *   override/suppression and must move with the rename.
+ *
+ * Scoped strictly to `ownerId`'s own items (KTD3) — never touches another
+ * owner's rows, even one with an identically-named default in the same
+ * category.
+ */
+async function repointDefaultRename(
+  tx: DbOrTx,
+  ownerId: string,
+  scope: ServiceScope,
+  category: string,
+  oldName: string,
+  newName: string,
+): Promise<void> {
+  const itemIds = await loadCategoryItemIds(tx, ownerId, scope, category);
+  if (itemIds.length === 0) return;
+
+  const ruleParentColumn =
+    scope === "firearm" ? serviceRule.firearmId : serviceRule.accessoryId;
+  const eventParentColumn =
+    scope === "firearm" ? serviceEvent.firearmId : serviceEvent.accessoryId;
+
+  // Overrides/suppressions first: their `service_rule` row carries the old
+  // name too, alongside any `service_event` rows the loop below also moves.
+  await tx
+    .update(serviceRule)
+    .set({ name: newName, updatedAt: new Date() })
+    .where(
+      and(inArray(ruleParentColumn, itemIds), eq(serviceRule.name, oldName)),
+    );
+
+  await tx
+    .update(serviceEvent)
+    .set({ ruleName: newName })
+    .where(
+      and(
+        inArray(eventParentColumn, itemIds),
+        eq(serviceEvent.ruleName, oldName),
+      ),
+    );
+}
+
+// ---- category defaults CRUD (owner-scoped, no grant path) ----
+
+/** An owner's default rule set for one scope+category, ordered by name. */
+export async function listServiceRuleDefaults(
+  actorId: string,
+  scope: ServiceScope,
+  category: string,
+): Promise<ServiceRuleDefaultRow[]> {
+  return loadDefaults(db, actorId, scope, category);
+}
+
+/**
+ * Create a category default. Field-shape validation (empty name, threshold
+ * bounds, missing threshold) runs before any transaction, matching
+ * `createLogEntry`; the duplicate-name check needs a sibling read, so it runs
+ * inside the transaction, before the insert.
+ */
+export async function createServiceRuleDefault(
+  actorId: string,
+  input: ServiceRuleDefaultInput,
+): Promise<ServiceRuleDefaultRow> {
+  const codes = validateServiceRuleSet([input]);
+  if (codes.length > 0) throw new ValidationError(codes);
+
+  const category = input.category.trim();
+  const name = input.name.trim();
+
+  try {
+    return await db.transaction(async (tx) => {
+      await assertWritesAllowed(tx);
+      const siblings = await loadDefaults(tx, actorId, input.scope, category);
+      assertNameAvailable(siblings, name);
+      const [row] = await tx
+        .insert(serviceRuleDefault)
+        .values({
+          ownerId: actorId,
+          scope: input.scope,
+          category,
+          name,
+          intervalDays: input.intervalDays ?? null,
+          intervalSessions: input.intervalSessions ?? null,
+          intervalRounds: input.intervalRounds ?? null,
+        })
+        .returning();
+      return row;
+    });
+  } catch (error: unknown) {
+    if (isUniqueNameViolation(error))
+      throw new ValidationError(["duplicateName"]);
+    throw error;
+  }
+}
+
+/**
+ * Update a category default's name/thresholds (full-replace, mirroring
+ * `updateAccessory`'s shape). A rename onto a name a sibling default in the
+ * same owner+scope+category already uses is rejected before the write.
+ *
+ * Renaming re-points every dependent row `repointDefaultRename` finds for
+ * this owner's own items in this exact scope+category, in the same
+ * transaction (see that function's doc for the full scope reasoning) — the
+ * default-level counterpart to `updateItemRule`'s item-level rename repoint.
+ */
+export async function updateServiceRuleDefault(
+  actorId: string,
+  defaultId: string,
+  input: ServiceRuleDefaultUpdateInput,
+): Promise<ServiceRuleDefaultRow> {
+  const codes = validateServiceRuleSet([input]);
+  if (codes.length > 0) throw new ValidationError(codes);
+
+  const name = input.name.trim();
+
+  try {
+    return await db.transaction(async (tx) => {
+      await assertWritesAllowed(tx);
+
+      // FOR UPDATE (mirrors `updateItemRule`'s F5 fix, same concurrency
+      // hazard one level up): locks this row for the rest of the
+      // transaction, so `existing.name` — what `repointDefaultRename` below
+      // repoints FROM — is always the name actually on the row, never a
+      // name a second, overlapping rename already moved past. Without the
+      // lock, two concurrent renames of the same default both read the
+      // row's starting name before either commits; whichever commits second
+      // then repoints dependent rows FROM that stale starting name, matching
+      // zero rows (the first rename already moved them), and strands history
+      // on the intermediate name.
+      const [existing] = await tx
+        .select()
+        .from(serviceRuleDefault)
+        .where(eq(serviceRuleDefault.id, defaultId))
+        .for("update")
+        .limit(1);
+      if (!existing || existing.ownerId !== actorId) throw new NotFoundError();
+
+      const siblings = await loadDefaults(
+        tx,
+        actorId,
+        existing.scope as ServiceScope,
+        existing.category,
+      );
+      assertNameAvailable(siblings, name, defaultId);
+
+      const [row] = await tx
+        .update(serviceRuleDefault)
+        .set({
+          name,
+          intervalDays: input.intervalDays ?? null,
+          intervalSessions: input.intervalSessions ?? null,
+          intervalRounds: input.intervalRounds ?? null,
+          updatedAt: new Date(),
+        })
+        .where(eq(serviceRuleDefault.id, defaultId))
+        .returning();
+      if (!row) throw new NotFoundError();
+
+      if (name !== existing.name) {
+        await repointDefaultRename(
+          tx,
+          actorId,
+          existing.scope as ServiceScope,
+          existing.category,
+          existing.name,
+          name,
+        );
+      }
+
+      return row;
+    });
+  } catch (error: unknown) {
+    if (isUniqueNameViolation(error))
+      throw new ValidationError(["duplicateName"]);
+    throw error;
+  }
+}
+
+/** Delete a category default. Owner-only, matching every other default op. */
+export async function deleteServiceRuleDefault(
+  actorId: string,
+  defaultId: string,
+): Promise<void> {
+  await db.transaction(async (tx) => {
+    await assertWritesAllowed(tx);
+    const [existing] = await tx
+      .select({ ownerId: serviceRuleDefault.ownerId })
+      .from(serviceRuleDefault)
+      .where(eq(serviceRuleDefault.id, defaultId))
+      .limit(1);
+    if (!existing || existing.ownerId !== actorId) throw new NotFoundError();
+    await tx
+      .delete(serviceRuleDefault)
+      .where(eq(serviceRuleDefault.id, defaultId));
+  });
+}
+
+// ---- item-rule CRUD (override, suppress, item-only; R5) ----
+
+/**
+ * Create an item rule: an override of a default, a suppression of one
+ * (`suppressed: true`, thresholds forced null), or an item-only rule with no
+ * matching default. Rejects a name already used by another rule on this same
+ * item before the insert.
+ *
+ * `preloadedSiblings`, when supplied, is used in place of this function's own
+ * `loadItemRules` call for the duplicate-name check — a caller that already
+ * loaded this item's rules (e.g. `service-actions.ts`'s `findItemRuleByName`,
+ * resolving which existing rule a UI action targets) can pass that list
+ * through rather than have it reloaded here a second time. The authorization
+ * check (`authorizeItemRuleWrite`) below is NEVER conditioned on this
+ * parameter — it always runs, so this function stays safe to call directly
+ * with no preload at all.
+ */
+export async function createItemRule(
+  actorId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+  input: ItemRuleInput,
+  preloadedSiblings?: ServiceRuleRow[],
+): Promise<ServiceRuleRow> {
+  const codes = validateServiceRuleSet([input]);
+  if (codes.length > 0) throw new ValidationError(codes);
+
+  const name = input.name.trim();
+  const suppressed = input.suppressed ?? false;
+
+  try {
+    return await db.transaction(async (tx) => {
+      await authorizeItemRuleWrite(tx, actorId, parentType, parentId);
+
+      const siblings =
+        preloadedSiblings ?? (await loadItemRules(tx, parentType, parentId));
+      assertNameAvailable(siblings, name);
+
+      // `validateServiceRuleSet` above already rejects `suppressed: true` WITH
+      // any threshold submitted (`suppressedWithThresholds`, F7 fix), so this
+      // ternary is defense-in-depth, not the primary guarantee: a suppressed
+      // rule's thresholds are always absent by the time we reach here.
+      const [row] = await tx
+        .insert(serviceRule)
+        .values({
+          firearmId: parentType === "firearm" ? parentId : null,
+          accessoryId: parentType === "accessory" ? parentId : null,
+          name,
+          suppressed,
+          intervalDays: suppressed ? null : (input.intervalDays ?? null),
+          intervalSessions: suppressed
+            ? null
+            : (input.intervalSessions ?? null),
+          intervalRounds: suppressed ? null : (input.intervalRounds ?? null),
+        })
+        .returning();
+      return row;
+    });
+  } catch (error: unknown) {
+    if (isUniqueNameViolation(error))
+      throw new ValidationError(["duplicateName"]);
+    throw error;
+  }
+}
+
+/**
+ * Update an item rule (full-replace). Renaming re-points that item's
+ * `service_event` rows from the old `rule_name` to the new one in the same
+ * transaction (KTD1); a rename onto a name the item already carries is
+ * rejected with `ValidationError` before any write.
+ *
+ * `preloadedSiblings` — see `createItemRule`'s doc — is used in place of this
+ * function's own `loadItemRules` call for the duplicate-name check, when
+ * supplied. The authorization check below always runs regardless.
+ */
+export async function updateItemRule(
+  actorId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+  ruleId: string,
+  input: ItemRuleInput,
+  preloadedSiblings?: ServiceRuleRow[],
+): Promise<ServiceRuleRow> {
+  const codes = validateServiceRuleSet([input]);
+  if (codes.length > 0) throw new ValidationError(codes);
+
+  const name = input.name.trim();
+  const suppressed = input.suppressed ?? false;
+
+  try {
+    return await db.transaction(async (tx) => {
+      await authorizeItemRuleWrite(tx, actorId, parentType, parentId);
+
+      // FOR UPDATE (F5 fix): locks this row for the rest of the transaction,
+      // so `existing.name` — what `repointServiceEvents` below repoints FROM —
+      // is always the name actually on the row, never a name a second,
+      // overlapping rename already moved past. Without the lock, two
+      // concurrent renames of the same rule both read the row's starting name
+      // before either commits; whichever commits second then repoints events
+      // FROM that stale starting name, matching zero rows (the first rename
+      // already moved them), and strands history on the intermediate name. The
+      // lock forces the second transaction's read to block until the first
+      // commits, so it re-reads the name the first rename actually left
+      // behind — mirroring `magazines/service.ts`'s `updateMagazine` lock.
+      const [existing] = await tx
+        .select()
+        .from(serviceRule)
+        .where(eq(serviceRule.id, ruleId))
+        .for("update")
+        .limit(1);
+      if (!existing || !belongsToParent(existing, parentType, parentId)) {
+        throw new NotFoundError();
+      }
+
+      const siblings =
+        preloadedSiblings ?? (await loadItemRules(tx, parentType, parentId));
+      assertNameAvailable(siblings, name, ruleId);
+
+      // `validateServiceRuleSet` above already rejects `suppressed: true` WITH
+      // any threshold submitted (`suppressedWithThresholds`, F7 fix), so this
+      // ternary is defense-in-depth, not the primary guarantee.
+      const [row] = await tx
+        .update(serviceRule)
+        .set({
+          name,
+          suppressed,
+          intervalDays: suppressed ? null : (input.intervalDays ?? null),
+          intervalSessions: suppressed
+            ? null
+            : (input.intervalSessions ?? null),
+          intervalRounds: suppressed ? null : (input.intervalRounds ?? null),
+          updatedAt: new Date(),
+        })
+        .where(eq(serviceRule.id, ruleId))
+        .returning();
+      if (!row) throw new NotFoundError();
+
+      if (name !== existing.name) {
+        await repointServiceEvents(
+          tx,
+          parentType,
+          parentId,
+          existing.name,
+          name,
+        );
+      }
+
+      return row;
+    });
+  } catch (error: unknown) {
+    if (isUniqueNameViolation(error))
+      throw new ValidationError(["duplicateName"]);
+    throw error;
+  }
+}
+
+/**
+ * Delete an item rule: restores an overridden rule to inherited, or restores
+ * a suppressed rule (R5). One row shape covers both (KTD6) — deleting it is
+ * the only operation either restoration needs.
+ */
+export async function deleteItemRule(
+  actorId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+  ruleId: string,
+): Promise<void> {
+  await db.transaction(async (tx) => {
+    await authorizeItemRuleWrite(tx, actorId, parentType, parentId);
+
+    const [existing] = await tx
+      .select({
+        firearmId: serviceRule.firearmId,
+        accessoryId: serviceRule.accessoryId,
+      })
+      .from(serviceRule)
+      .where(eq(serviceRule.id, ruleId))
+      .limit(1);
+    if (!existing || !belongsToParent(existing, parentType, parentId)) {
+      throw new NotFoundError();
+    }
+
+    await tx.delete(serviceRule).where(eq(serviceRule.id, ruleId));
+  });
+}
+
+// ---- reads ----
+
+/** An item's own raw rule rows (overrides, suppressions, item-only rules). */
+export async function listItemRules(
+  actorId: string,
+  parentType: ServiceParentType,
+  parentId: string,
+): Promise<ServiceRuleRow[]> {
+  if (parentType === "firearm") {
+    await requireFirearmVisible(db, actorId, parentId);
+  } else {
+    await requireAccessoryOwner(db, actorId, parentId);
+  }
+  return loadItemRules(db, parentType, parentId);
+}
+
+/**
+ * The owner's distinct accessory categories, alphabetically (KTD8) — powers
+ * the defaults surface so a typo doesn't silently strand a whole category's
+ * default set. Derived on read; nothing is stored.
+ */
+export async function listOwnerAccessoryCategories(
+  actorId: string,
+): Promise<string[]> {
+  const rows = await db
+    .selectDistinct({ category: accessory.category })
+    .from(accessory)
+    .where(eq(accessory.ownerId, actorId))
+    .orderBy(asc(accessory.category));
+  return rows.map((row) => row.category);
+}
+
+/**
+ * Every category the owner has configured at least one default for, in one
+ * scope (U7) — a `SELECT DISTINCT category` over `service_rule_default`, not
+ * over `accessory` (that's `listOwnerAccessoryCategories`, KTD8, above).
+ * Alongside that function, this is what lets the defaults settings surface
+ * keep showing a category once it has been armed, even after its only
+ * matching accessory is deleted, or before one ever existed. Firearm
+ * categories never need this: `FIREARM_TYPES` is the fixed, already-known
+ * list.
+ */
+export async function listConfiguredCategories(
+  actorId: string,
+  scope: ServiceScope,
+): Promise<string[]> {
+  const rows = await db
+    .selectDistinct({ category: serviceRuleDefault.category })
+    .from(serviceRuleDefault)
+    .where(
+      and(
+        eq(serviceRuleDefault.ownerId, actorId),
+        eq(serviceRuleDefault.scope, scope),
+      ),
+    )
+    .orderBy(asc(serviceRuleDefault.category));
+  return rows.map((row) => row.category);
+}
+
+/**
+ * Count of the owner's items in one category — firearms of a `type`, or
+ * accessories of a `category` (U7). Surfaced next to each category on the
+ * defaults settings screen so editing or deleting a default states plainly
+ * how many items it reaches (R4's live-inheritance consequence) before the
+ * owner saves. A plain per-category count, not a per-rule one: every item in
+ * the category resolves some version of every rule in the set (its own
+ * override, or the default), so "how many items does this category's default
+ * set reach" is answered at the category level, one step up from any single
+ * rule's override state.
+ */
+export async function countItemsInCategory(
+  actorId: string,
+  scope: ServiceScope,
+  category: string,
+): Promise<number> {
+  const [row] =
+    scope === "firearm"
+      ? await db
+          .select({ total: count() })
+          .from(firearm)
+          .where(and(eq(firearm.ownerId, actorId), eq(firearm.type, category)))
+      : await db
+          .select({ total: count() })
+          .from(accessory)
+          .where(
+            and(
+              eq(accessory.ownerId, actorId),
+              eq(accessory.category, category),
+            ),
+          );
+  return row?.total ?? 0;
+}
+
+/**
+ * Every one of the owner's default rule sets for one scope, grouped by
+ * category, in a single query (U7's settings page) — the batched counterpart
+ * to calling `listServiceRuleDefaults` once per category, which the settings
+ * page's `loadSections` used to do (once per firearm type, once per
+ * accessory category), breaking the batching discipline the rest of the
+ * service-intervals feature follows (KTD4-style, though this page predates
+ * that pin). A category with no defaults yet is simply absent from the map.
+ */
+export async function listServiceRuleDefaultsByCategory(
+  actorId: string,
+  scope: ServiceScope,
+): Promise<Map<string, ServiceRuleDefaultRow[]>> {
+  const rows = await db
+    .select()
+    .from(serviceRuleDefault)
+    .where(
+      and(
+        eq(serviceRuleDefault.ownerId, actorId),
+        eq(serviceRuleDefault.scope, scope),
+      ),
+    )
+    .orderBy(asc(serviceRuleDefault.category), asc(serviceRuleDefault.name));
+
+  const byCategory = new Map<string, ServiceRuleDefaultRow[]>();
+  for (const row of rows) {
+    const rules = byCategory.get(row.category) ?? [];
+    rules.push(row);
+    byCategory.set(row.category, rules);
+  }
+  return byCategory;
+}
+
+/**
+ * The owner's item count per category for one scope, in a single `GROUP BY`
+ * query (U7's settings page) — the batched counterpart to calling
+ * `countItemsInCategory` once per category. A category with no items yet is
+ * simply absent from the map (callers read that as zero, matching
+ * `countItemsInCategory`'s `row?.total ?? 0` fallback).
+ */
+export async function countItemsByCategory(
+  actorId: string,
+  scope: ServiceScope,
+): Promise<Map<string, number>> {
+  const rows =
+    scope === "firearm"
+      ? await db
+          .select({ category: firearm.type, total: count() })
+          .from(firearm)
+          .where(eq(firearm.ownerId, actorId))
+          .groupBy(firearm.type)
+      : await db
+          .select({ category: accessory.category, total: count() })
+          .from(accessory)
+          .where(eq(accessory.ownerId, actorId))
+          .groupBy(accessory.category);
+  return new Map(rows.map((row) => [row.category, row.total]));
+}
diff --git a/src/domain/service-intervals/validate-event.ts b/src/domain/service-intervals/validate-event.ts
new file mode 100644
index 00000000..0dcb9380
--- /dev/null
+++ b/src/domain/service-intervals/validate-event.ts
@@ -0,0 +1,123 @@
+/**
+ * Service-event validation (service-intervals plan, U8). Pure — no DB, no
+ * Next.js — mirroring `validate.ts`'s split from `rules-service.ts`, so
+ * `log-service-form.tsx` (a client component) can import this module
+ * without ever pulling `events-service.ts` (which imports `@/src/db/client`
+ * and, transitively, the server-only `pg` package) into the browser bundle.
+ */
+
+import { differenceInCalendarDays, parseISO } from "date-fns";
+import {
+  FUTURE_DATE_TOLERANCE_DAYS,
+  ISO_DATE,
+  isRealCalendarDate,
+} from "@/src/lib/dates";
+
+export interface ServiceEventInput {
+  ruleName: string;
+  servicedOn: string;
+  notes?: string;
+}
+
+/**
+ * Input for correcting an EXISTING service event (the correction path this
+ * unit adds — U4 originally shipped only create/list, with no way back out
+ * of a mis-logged event). Deliberately narrower than `ServiceEventInput`: no
+ * `ruleName`, and no parent at all. An edit may only ever change
+ * `servicedOn` and/or `notes` — see `updateServiceEvent`'s doc in
+ * `events-service.ts` for why the rule and parent stay fixed for the life of
+ * an event.
+ */
+export interface ServiceEventUpdateInput {
+  servicedOn: string;
+  notes?: string;
+}
+
+export type ServiceEventValidationCode =
+  | "emptyRuleName"
+  | "emptyServicedOn"
+  | "invalidServicedOn"
+  | "servicedOnInFuture"
+  // Thrown by `events-service.ts` (DB-backed; never by the pure validators in
+  // this file) — `ruleNotFound` when a submitted `ruleName` no longer
+  // resolves against the item's current effective rule set (F2 fix, guards
+  // against a rule renamed between render and submit), `bulkTooLarge` when a
+  // `logServiceEventsBulk` call exceeds `MAX_BULK_SERVICE_ITEMS` (F6 fix).
+  // Both live on this union anyway so every caller of `logServiceEvent` /
+  // `logServiceEventsBulk` sees one complete set of possible failure codes.
+  | "ruleNotFound"
+  | "bulkTooLarge";
+
+/**
+ * `servicedOn` must be non-empty, a real calendar date, and not more than
+ * `FUTURE_DATE_TOLERANCE_DAYS` after `asOf` (U8's log-service form contract)
+ * — a service event records something that already happened (R14), so a
+ * future date is rejected the same way both here and in the client form that
+ * reuses this validator.
+ *
+ * The one-day tolerance (F1 fix) exists because `asOf` defaults to the
+ * SERVER's clock, not the submitter's: a user whose local calendar day is
+ * genuinely ahead of the server's (server on UTC, submitter east of it)
+ * would otherwise have their own local "today" — exactly what the client
+ * form's `todayIso()` pre-fills — rejected as future for part of every day.
+ * See `FUTURE_DATE_TOLERANCE_DAYS`'s doc in `src/lib/dates.ts` for the full
+ * rationale; a date more than one day ahead is still a genuine future date
+ * and stays rejected.
+ *
+ * `asOf` defaults to "now" but is an explicit parameter so this stays a pure,
+ * deterministic function for tests (KTD5's local-frame calendar-day compare,
+ * via `date-fns`'s `differenceInCalendarDays`, matching `derive.ts`).
+ */
+export function validateServicedOn(
+  servicedOn: string,
+  asOf: Date = new Date(),
+): Array<"emptyServicedOn" | "invalidServicedOn" | "servicedOnInFuture"> {
+  const codes: Array<
+    "emptyServicedOn" | "invalidServicedOn" | "servicedOnInFuture"
+  > = [];
+  const trimmed = (servicedOn ?? "").trim();
+  if (trimmed === "") {
+    codes.push("emptyServicedOn");
+  } else if (!ISO_DATE.test(trimmed) || !isRealCalendarDate(trimmed)) {
+    codes.push("invalidServicedOn");
+  } else if (
+    differenceInCalendarDays(parseISO(trimmed), asOf) >
+    FUTURE_DATE_TOLERANCE_DAYS
+  ) {
+    codes.push("servicedOnInFuture");
+  }
+  return codes;
+}
+
+/**
+ * Exported for reuse by both `events-service.ts` (server, re-validates
+ * before every write) and `log-service-form.tsx` (client, same codes/
+ * messages for immediate feedback) — matching the reuse pattern
+ * `validateServiceRuleSet` already establishes for the defaults form.
+ */
+export function validateServiceEventInput(
+  input: ServiceEventInput,
+  asOf: Date = new Date(),
+): ServiceEventValidationCode[] {
+  const codes: ServiceEventValidationCode[] = [];
+  if (input.ruleName.trim() === "") codes.push("emptyRuleName");
+  codes.push(...validateServicedOn(input.servicedOn, asOf));
+  return codes;
+}
+
+/**
+ * Validates a service-event correction (`ServiceEventUpdateInput`) — reused
+ * by both `events-service.ts` (server, re-validates before every write) and
+ * `service-history.tsx`'s edit form (client, same codes/messages for
+ * immediate feedback), matching `validateServiceEventInput`'s reuse shape.
+ * Just `servicedOn`, through the exact same `validateServicedOn` (including
+ * its one-day future tolerance) the log path uses — there is no `ruleName`
+ * to validate here; an edit can never submit one (`ServiceEventUpdateInput`
+ * has no such field at all).
+ */
+export function validateServiceEventUpdateInput(
+  input: ServiceEventUpdateInput,
+  asOf: Date = new Date(),
+): ServiceEventValidationCode[] {
+  return validateServicedOn(input.servicedOn, asOf);
+}
diff --git a/src/domain/service-intervals/validate.ts b/src/domain/service-intervals/validate.ts
new file mode 100644
index 00000000..d147eeb7
--- /dev/null
+++ b/src/domain/service-intervals/validate.ts
@@ -0,0 +1,92 @@
+/**
+ * Service-rule validation (service-intervals plan, U2). Pure — no DB, no
+ * Next.js. Returns ALL failure codes together over a submitted SET of rules
+ * (a category default set, or one item's rules), matching the all-codes-
+ * together shape of `validateLogEntry` / `validateMagazine`. Duplicate-name
+ * detection only makes sense across a set, so this validator always takes an
+ * array rather than one rule at a time.
+ */
+
+import { MIN_THRESHOLD } from "./constants";
+
+export type ServiceRuleValidationCode =
+  | "emptyName"
+  | "duplicateName"
+  | "thresholdTooLow"
+  | "missingThreshold"
+  | "suppressedWithThresholds";
+
+export interface ServiceRuleInput {
+  name: string;
+  suppressed?: boolean;
+  intervalDays?: number | null;
+  intervalSessions?: number | null;
+  intervalRounds?: number | null;
+}
+
+function isSetThreshold(value: number | null | undefined): value is number {
+  return value !== null && value !== undefined;
+}
+
+function hasAnyThreshold(rule: ServiceRuleInput): boolean {
+  return (
+    isSetThreshold(rule.intervalDays) ||
+    isSetThreshold(rule.intervalSessions) ||
+    isSetThreshold(rule.intervalRounds)
+  );
+}
+
+function hasThresholdBelowMin(rule: ServiceRuleInput): boolean {
+  return [rule.intervalDays, rule.intervalSessions, rule.intervalRounds].some(
+    (value) =>
+      isSetThreshold(value) &&
+      (!Number.isInteger(value) || value < MIN_THRESHOLD),
+  );
+}
+
+/**
+ * Validate a submitted set of service rules (a category default set, or one
+ * item's rule rows), returning every applicable failure code across the
+ * whole set (R2, KTD6):
+ * - `emptyName` — a rule name is empty or whitespace-only.
+ * - `duplicateName` — two rules in this same set share a (trimmed) name.
+ * - `thresholdTooLow` — a set threshold is below `MIN_THRESHOLD` (zero or
+ *   negative) or not a whole number (e.g. `1.5`) — thresholds are stored in
+ *   integer DB columns, so a non-integer must be rejected here rather than
+ *   fail as an unhandled driver error.
+ * - `missingThreshold` — a rule sets no threshold and is not suppressed.
+ * - `suppressedWithThresholds` — a rule is BOTH suppressed and carries a set
+ *   threshold (F7 fix). `createItemRule`/`updateItemRule` force a suppressed
+ *   rule's thresholds to `null` regardless of what was submitted (KTD6:
+ *   suppression and thresholds are mutually exclusive on one row), so a
+ *   caller submitting both together is a caller bug — explicit rejection
+ *   here, rather than silently discarding the submitted thresholds, is what
+ *   surfaces that bug instead of hiding it.
+ */
+export function validateServiceRuleSet(
+  rules: ServiceRuleInput[],
+): ServiceRuleValidationCode[] {
+  const codes = new Set<ServiceRuleValidationCode>();
+  const seenNames = new Set<string>();
+
+  for (const rule of rules) {
+    const trimmedName = rule.name.trim();
+    if (trimmedName === "") {
+      codes.add("emptyName");
+    } else if (seenNames.has(trimmedName)) {
+      codes.add("duplicateName");
+    } else {
+      seenNames.add(trimmedName);
+    }
+
+    if (hasThresholdBelowMin(rule)) codes.add("thresholdTooLow");
+
+    if (rule.suppressed === true) {
+      if (hasAnyThreshold(rule)) codes.add("suppressedWithThresholds");
+    } else if (!hasAnyThreshold(rule)) {
+      codes.add("missingThreshold");
+    }
+  }
+
+  return [...codes];
+}
diff --git a/src/domain/summary/__tests__/summary.test.ts b/src/domain/summary/__tests__/summary.test.ts
index b2f72266..9fe613d8 100644
--- a/src/domain/summary/__tests__/summary.test.ts
+++ b/src/domain/summary/__tests__/summary.test.ts
@@ -1,10 +1,24 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { Pool } from "pg";
+import { createGrant } from "@/src/auth/grants";
+import { db } from "@/src/db/client";
 import { createMagazine } from "@/src/domain/magazines/service";
+import {
+  type ItemDueEntry,
+  listDueForVisibleCollection,
+  type RuleDueState,
+} from "@/src/domain/service-intervals/due-service";
+import {
+  createItemRule,
+  createServiceRuleDefault,
+} from "@/src/domain/service-intervals/rules-service";
 import {
   createUser,
   deleteUsers,
+  makeAccessory,
   makeAmmo,
   makeFirearm,
+  makeServiceEvent,
 } from "@/src/test-support/factories";
 import {
   type AmmoSnapshot,
@@ -21,6 +35,64 @@ function firearmRow(s: ReturnType<typeof computeSummary>, id: string) {
   return s.firearmCounts.find((r) => r.id === id);
 }
 
+/**
+ * A minimal `RuleDueState` fixture — only `due` varies across these tests.
+ * Branched, not a flat `due, trippedAxis: due ? "days" : null`, because
+ * `RuleDueState` is a discriminated union: only this shape lets TypeScript
+ * confirm the fixture matches what `isDue` ever actually produces.
+ */
+function dueRule(name: string, due: boolean): RuleDueState {
+  const base = {
+    name,
+    inheritanceState: "item-only" as const,
+    intervalDays: null,
+    intervalSessions: null,
+    intervalRounds: null,
+    measureFrom: new Date(2026, 0, 1),
+    counts: { days: 0, sessions: 0, rounds: 0 },
+  };
+  return due
+    ? { ...base, due: true, trippedAxis: "days" }
+    : { ...base, due: false, trippedAxis: null };
+}
+
+function dueEntry(
+  parentType: ItemDueEntry["parentType"],
+  parentId: string,
+  rules: RuleDueState[],
+): ItemDueEntry {
+  return { parentType, parentId, rules };
+}
+
+/**
+ * Counts every SQL round trip issued through `pg`'s `Pool.prototype.query`
+ * while `fn` runs — mirrors `due-service.test.ts`'s helper (U4), which proved
+ * `listDueForVisibleCollection` is bounded; this proves `inventorySummary`
+ * stays bounded when it threads that same call through (U9's Definition of
+ * Done: "the summary loads without a per-item query as the visible set
+ * grows").
+ */
+async function countPoolQueries<T>(
+  fn: () => Promise<T>,
+): Promise<{ result: T; count: number }> {
+  const original = Pool.prototype.query;
+  let count = 0;
+  Pool.prototype.query = function (
+    this: Pool,
+    ...args: Parameters<typeof original>
+  ) {
+    count += 1;
+    // biome-ignore lint/suspicious/noExplicitAny: passthrough to the original overloaded pg method
+    return (original as any).apply(this, args);
+  } as typeof original;
+  try {
+    const result = await fn();
+    return { result, count };
+  } finally {
+    Pool.prototype.query = original;
+  }
+}
+
 // Pure aggregation — parity digest §12.3 (no DB).
 describe("computeSummary (parity §7)", () => {
   test("covers AE2/AE7: the digest worked example", () => {
@@ -134,9 +206,10 @@ describe("computeSummary (parity §7)", () => {
 
   test("empty inventory yields zeros/empty arrays, never null (R68)", () => {
     const s = computeSummary([], []);
-    // U5: computeSummary's return shape grew ammo roll-up fields — the
-    // magazine/firearm fields it originally asserted stay 0/[]/[] (regression),
-    // and the new ammo fields are asserted zero/empty too (never null, R68-style).
+    // U5: computeSummary's return shape grew ammo roll-up fields, and U9 grew
+    // it again with the service roll-up — the magazine/firearm fields it
+    // originally asserted stay 0/[]/[] (regression), and every added field is
+    // asserted zero/empty too (never null, R68-style).
     expect(s).toEqual({
       totalMagazines: 0,
       byCaliber: [],
@@ -145,6 +218,8 @@ describe("computeSummary (parity §7)", () => {
       ammoEntriesLow: 0,
       ammoCalibersLow: 0,
       caliberCoverage: [],
+      itemsDue: 0,
+      rulesDue: 0,
     });
   });
 });
@@ -272,6 +347,49 @@ describe("computeSummary — ammo roll-ups (U5)", () => {
   });
 });
 
+// Service due roll-up (service-intervals plan U9, R19). Pure — folds
+// pre-computed `ItemDueEntry[]` fixtures (never re-derives due state itself,
+// KTD4), mirroring the ammo roll-up block's style above.
+describe("computeSummary — service roll-up (U9)", () => {
+  test("covers R19: counts items with >=1 due rule (breadth) and due rules in total (volume) from one fold", () => {
+    const entries: ItemDueEntry[] = [
+      dueEntry("firearm", "f1", [
+        dueRule("Cleaning", true),
+        dueRule("Barrel", true),
+      ]),
+      dueEntry("firearm", "f2", [dueRule("Cleaning", false)]),
+      dueEntry("accessory", "a1", [dueRule("Cleaning", true)]),
+    ];
+    const s = computeSummary([], [], [], entries);
+    expect(s.itemsDue).toBe(2);
+    expect(s.rulesDue).toBe(3);
+  });
+
+  test("an item with no due rules contributes to neither count", () => {
+    const entries: ItemDueEntry[] = [
+      dueEntry("firearm", "f1", [
+        dueRule("Cleaning", false),
+        dueRule("Barrel", false),
+      ]),
+    ];
+    const s = computeSummary([], [], [], entries);
+    expect(s.itemsDue).toBe(0);
+    expect(s.rulesDue).toBe(0);
+  });
+
+  test("no dueEntries argument yields a zero roll-up, not an error (default param)", () => {
+    const s = computeSummary([], []);
+    expect(s.itemsDue).toBe(0);
+    expect(s.rulesDue).toBe(0);
+  });
+
+  test("an empty entries array (no visible items) yields a zero roll-up", () => {
+    const s = computeSummary([], [], [], []);
+    expect(s.itemsDue).toBe(0);
+    expect(s.rulesDue).toBe(0);
+  });
+});
+
 describe("inventorySummary (U7, viewer-relative)", () => {
   let userA = "";
   let userB = "";
@@ -332,3 +450,222 @@ describe("inventorySummary (U7, viewer-relative)", () => {
     expect(bSummary.caliberCoverage).toEqual([]);
   });
 });
+
+/**
+ * `inventorySummary`'s service roll-up, end to end (service-intervals plan
+ * U9, R19/R20/R21). Each test creates its own isolated owner(s) (mirrors
+ * `due-service.test.ts`'s isolation style) rather than sharing the userA/userB
+ * pair above, so ordering never matters. A firearm's `acquiredDate` is always
+ * set far in the past with a 1-day threshold — due regardless of the actual
+ * run date, with no need to pin `asOf` (`inventorySummary` doesn't expose one).
+ */
+describe("inventorySummary — service roll-up (U9)", () => {
+  const createdUsers: string[] = [];
+
+  afterAll(async () => {
+    await deleteUsers(...createdUsers);
+  });
+
+  async function newOwner(label: string): Promise<string> {
+    const id = await createUser(label);
+    createdUsers.push(id);
+    return id;
+  }
+
+  const LONG_AGO = "2020-01-01";
+  const OVERDUE = { intervalDays: 1 };
+
+  test("covers AE5: a suppressed rule that would otherwise be due contributes to neither count", async () => {
+    const owner = await newOwner("u9ae5");
+    const fa = await makeFirearm(owner, {
+      type: "rifle",
+      acquiredDate: LONG_AGO,
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      ...OVERDUE,
+    });
+    await createItemRule(owner, "firearm", fa.id, {
+      name: "Cleaning",
+      suppressed: true,
+    });
+
+    const summary = await inventorySummary(owner);
+    expect(summary.itemsDue).toBe(0);
+    expect(summary.rulesDue).toBe(0);
+  });
+
+  test("covers R19: three items due across five rules — breadth and volume both visible", async () => {
+    const owner = await newOwner("u9r19");
+
+    await makeFirearm(owner, {
+      type: "rifle",
+      acquiredDate: LONG_AGO,
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      ...OVERDUE,
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Barrel",
+      ...OVERDUE,
+    });
+
+    await makeFirearm(owner, {
+      type: "pistol",
+      acquiredDate: LONG_AGO,
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "pistol",
+      name: "Cleaning",
+      ...OVERDUE,
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "pistol",
+      name: "Recoil spring",
+      ...OVERDUE,
+    });
+
+    const optic = await makeAccessory(owner, { category: "Optic" });
+    await createServiceRuleDefault(owner, {
+      scope: "accessory",
+      category: "Optic",
+      name: "Zero check",
+      ...OVERDUE,
+    });
+    // This fixture doesn't set an acquired date, so origin falls back to
+    // `createdAt` (KTD9), which is "now" for a freshly-inserted row, so a
+    // 1-day threshold alone would never trip. A backdated service event gives
+    // the rule an old measure-from point instead, same as a real owner's
+    // history would.
+    await makeServiceEvent(
+      { accessoryId: optic.id },
+      { ruleName: "Zero check", servicedOn: LONG_AGO },
+    );
+
+    const summary = await inventorySummary(owner);
+    expect(summary.itemsDue).toBe(3);
+    expect(summary.rulesDue).toBe(5);
+  });
+
+  test("a shared firearm that is due appears in the grantee's roll-up, using its owner's defaults", async () => {
+    const owner = await newOwner("u9shareOwner");
+    const grantee = await newOwner("u9shareGrantee");
+    const fa = await makeFirearm(owner, {
+      type: "rifle",
+      acquiredDate: LONG_AGO,
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      ...OVERDUE,
+    });
+    await createGrant(db, {
+      actorId: owner,
+      granteeId: grantee,
+      parentType: "firearm",
+      parentId: fa.id,
+      permission: "view",
+    });
+
+    const summary = await inventorySummary(grantee);
+    expect(summary.itemsDue).toBe(1);
+    expect(summary.rulesDue).toBe(1);
+  });
+
+  test("an item due only because of an accessory mounted to it is not itself marked — the accessory's own entry carries the due rule", async () => {
+    const owner = await newOwner("u9accessoryOnly");
+    const fa = await makeFirearm(owner, {
+      type: "rifle",
+      acquiredDate: LONG_AGO,
+    });
+    // No default/rule ever tracks the firearm itself.
+    const suppressor = await makeAccessory(owner, {
+      category: "Suppressor",
+      currentFirearmId: fa.id,
+    });
+    await createServiceRuleDefault(owner, {
+      scope: "accessory",
+      category: "Suppressor",
+      name: "Cleaning",
+      ...OVERDUE,
+    });
+    // This fixture doesn't set an acquired date, so origin falls back to
+    // `createdAt` (KTD9) — backdate a service event so the 1-day threshold
+    // actually trips (see the R19 test above).
+    await makeServiceEvent(
+      { accessoryId: suppressor.id },
+      { ruleName: "Cleaning", servicedOn: LONG_AGO },
+    );
+
+    const summary = await inventorySummary(owner);
+    expect(summary.itemsDue).toBe(1);
+    expect(summary.rulesDue).toBe(1);
+
+    // The firearm has no effective rules of its own, so it's absent from
+    // `listDueForVisibleCollection`'s output entirely — never marked due on
+    // the accessory's account.
+    const dueEntries = await listDueForVisibleCollection(owner);
+    const firearmEntry = dueEntries.find(
+      (entry) => entry.parentType === "firearm" && entry.parentId === fa.id,
+    );
+    expect(firearmEntry).toBeUndefined();
+  });
+
+  test("an owner with no defaults configured anywhere sees a zero roll-up, not an empty-state error", async () => {
+    const owner = await newOwner("u9zero");
+    await makeFirearm(owner, { type: "rifle" }); // an item exists; nothing tracks it
+    const summary = await inventorySummary(owner);
+    expect(summary.itemsDue).toBe(0);
+    expect(summary.rulesDue).toBe(0);
+  });
+
+  test("inventorySummary's service roll-up loads in a bounded number of queries as the visible set grows (KTD4)", async () => {
+    const owner = await newOwner("u9bounded");
+    await createServiceRuleDefault(owner, {
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      ...OVERDUE,
+    });
+
+    async function addRifles(n: number): Promise<void> {
+      for (let i = 0; i < n; i += 1) {
+        await makeFirearm(owner, {
+          type: "rifle",
+          name: `Rifle ${i}`,
+          acquiredDate: LONG_AGO,
+        });
+      }
+    }
+
+    await addRifles(2);
+    const { result: small, count: smallCount } = await countPoolQueries(() =>
+      inventorySummary(owner),
+    );
+    expect(small.itemsDue).toBe(2);
+
+    await addRifles(8); // 10 firearms total now
+    const { result: large, count: largeCount } = await countPoolQueries(() =>
+      inventorySummary(owner),
+    );
+    expect(large.itemsDue).toBe(10);
+
+    // Bounded regardless of collection size (Definition of Done, U9/U4) —
+    // never a per-item query: 5x the items must not grow the query count.
+    // `<=` rather than exact equality: the query count is measured
+    // process-wide, so an unrelated concurrent query landing in either
+    // window would make an exact-equality assertion flake without the
+    // underlying "no per-item growth" property actually regressing.
+    expect(largeCount).toBeLessThanOrEqual(smallCount);
+  });
+});
diff --git a/src/domain/summary/summary.ts b/src/domain/summary/summary.ts
index cd2b1b29..ea09ba0e 100644
--- a/src/domain/summary/summary.ts
+++ b/src/domain/summary/summary.ts
@@ -3,10 +3,15 @@ import { isLowStock } from "@/src/domain/ammo/validate";
 import { listFirearms } from "@/src/domain/firearms/service";
 import { listMagazines } from "@/src/domain/magazines/service";
 import { effectiveCapacity } from "@/src/domain/magazines/validate";
+import {
+  type ItemDueEntry,
+  listDueForVisibleCollection,
+} from "@/src/domain/service-intervals/due-service";
 
 /**
  * Inventory summary (U7, parity §7; ammo roll-ups added in the ammo plan's
- * U5). Computed in memory over the requester's VISIBLE inventory snapshot only
+ * U5; the service due roll-up added in the service-intervals plan's U9).
+ * Computed in memory over the requester's VISIBLE inventory snapshot only
  * (R41). The pure `computeSummary` is the parity aggregation; `inventorySummary`
  * loads the viewer-relative snapshot and applies it. Empty inventory yields an
  * all-zero summary, never null (R68).
@@ -75,6 +80,10 @@ export interface Summary {
   ammoCalibersLow: number;
   /** Firearm calibers with no ammo, or only low ammo — all-lots rule (R12), sorted alphabetically. */
   caliberCoverage: CaliberCoverage[];
+  /** Visible firearms/accessories with at least one due service rule (R19). */
+  itemsDue: number;
+  /** Total due service rules across the visible collection (R19). */
+  rulesDue: number;
 }
 
 /**
@@ -96,6 +105,7 @@ export function computeSummary(
   firearms: FirearmIdentity[],
   magazines: MagazineSnapshot[],
   ammo: AmmoSnapshot[] = [],
+  dueEntries: ItemDueEntry[] = [],
 ): Summary {
   // Keyed by the normalized caliber (trim + case-fold) so "9mm" and "9MM " group
   // as one row — the same matching `computeAmmoRollups` uses (#52), keeping a
@@ -140,6 +150,7 @@ export function computeSummary(
 
   const { ammoEntriesLow, ammoCalibersLow, caliberCoverage } =
     computeAmmoRollups(firearms, ammo);
+  const { itemsDue, rulesDue } = computeServiceRollup(dueEntries);
 
   return {
     totalMagazines: magazines.length,
@@ -149,6 +160,8 @@ export function computeSummary(
     ammoEntriesLow,
     ammoCalibersLow,
     caliberCoverage,
+    itemsDue,
+    rulesDue,
   };
 }
 
@@ -206,17 +219,62 @@ function computeAmmoRollups(
   };
 }
 
-/** Load the requester's viewer-relative visible inventory and summarize it. */
-export async function inventorySummary(actorId: string): Promise<Summary> {
-  const [firearms, magazines, ammoLots] = await Promise.all([
-    listFirearms(actorId),
-    listMagazines(actorId),
-    listAmmo(actorId),
-  ]);
+/**
+ * Service due roll-up (service-intervals plan U9, R19/R20/R21, KTD4). Folds
+ * `listDueForVisibleCollection`'s per-item, per-rule due state — already
+ * derived in a bounded number of queries, never re-derived here — into two
+ * counts: breadth (`itemsDue`, items with at least one due rule) and volume
+ * (`rulesDue`, total due rules across the visible collection). An item that
+ * is due only because of an accessory mounted to it does NOT contribute here
+ * on the firearm's account — `listDueForVisibleCollection` already returns
+ * the firearm and the accessory as separate entries, so the accessory's due
+ * rule only ever counts toward the accessory's own entry.
+ */
+function computeServiceRollup(
+  entries: ItemDueEntry[],
+): Pick<Summary, "itemsDue" | "rulesDue"> {
+  let itemsDue = 0;
+  let rulesDue = 0;
+  for (const entry of entries) {
+    const dueRuleCount = entry.rules.filter((rule) => rule.due).length;
+    if (dueRuleCount > 0) itemsDue += 1;
+    rulesDue += dueRuleCount;
+  }
+  return { itemsDue, rulesDue };
+}
+
+/**
+ * Load the requester's viewer-relative visible inventory and summarize it.
+ * Accepts an optional pre-fetched `dueEntries` (already the same batched,
+ * bounded load `listDueForVisibleCollection` returns) so a caller that also
+ * needs the raw entries — e.g. to mark individual rows due, R20 — can fetch
+ * once and pass the result here instead of triggering the full due-resolution
+ * pipeline (defaults + item rules + last-service-points + session rows) a
+ * second time. When omitted, behavior is identical to before: this function
+ * fetches it itself.
+ *
+ * Also accepts an optional pre-fetched `firearms` (the same visible-firearm
+ * set `listFirearms` would return) so a caller that has already loaded it —
+ * e.g. the firearms list page — can skip `listFirearms`'s two round trips
+ * (`getVisibleIds` + select) a second time. When omitted, this function
+ * fetches it itself, identical to before.
+ */
+export async function inventorySummary(
+  actorId: string,
+  dueEntries?: ItemDueEntry[],
+  firearms?: FirearmIdentity[],
+): Promise<Summary> {
+  const [resolvedFirearms, magazines, ammoLots, resolvedDueEntries] =
+    await Promise.all([
+      firearms ?? listFirearms(actorId),
+      listMagazines(actorId),
+      listAmmo(actorId),
+      dueEntries ?? listDueForVisibleCollection(actorId),
+    ]);
   const ammo: AmmoSnapshot[] = ammoLots.map((lot) => ({
     caliber: lot.caliber,
     quantityRounds: lot.quantityRounds,
     lowStockThreshold: lot.lowStockThreshold,
   }));
-  return computeSummary(firearms, magazines, ammo);
+  return computeSummary(resolvedFirearms, magazines, ammo, resolvedDueEntries);
 }
diff --git a/src/domain/validation-messages.ts b/src/domain/validation-messages.ts
index 537f621b..c797e263 100644
--- a/src/domain/validation-messages.ts
+++ b/src/domain/validation-messages.ts
@@ -8,6 +8,7 @@ import {
   MAGPUL_LABEL_ALLOWED_DESCRIPTION,
   MAX_LABEL_LENGTH,
 } from "./magazines/constants";
+import { MAX_BULK_SERVICE_ITEMS } from "./service-intervals/constants";
 
 export const VALIDATION_MESSAGES: Record<string, string> = {
   emptyName: "Name is required",
@@ -16,6 +17,8 @@ export const VALIDATION_MESSAGES: Record<string, string> = {
   invalidAction: "Select a valid firearm action",
   typeRequired: "Choose a firearm type",
   actionRequired: "Choose a firearm action",
+  invalidAcquiredDate: "Enter a valid acquired date",
+  acquiredDateInFuture: "Acquired date cannot be in the future",
   emptyBrandModel: "Brand/model is required",
   baseCapacityTooLow: "Base capacity must be at least 1",
   baseCapacityInvalid:
@@ -45,6 +48,21 @@ export const VALIDATION_MESSAGES: Record<string, string> = {
   negativeCostCents: "Cost cannot be negative",
   invalidCostCents: "Enter a valid cost (up to $21,474,836.47)",
   invalidInstalledDate: "Enter a valid installed date",
+  duplicateName: "A rule with this name already exists here",
+  thresholdTooLow: "Thresholds must be at least 1",
+  missingThreshold: "Set at least one threshold (days, sessions, or rounds)",
+  emptyRuleName: "Rule name is required",
+  invalidScope: "Select a valid scope (firearm or accessory)",
+  invalidCategory: "Category must be text",
+  invalidRuleName: "Rule name must be text",
+  emptyServicedOn: "Date is required",
+  invalidServicedOn: "Enter a valid date",
+  servicedOnInFuture: "Date cannot be in the future",
+  ruleNotFound:
+    "This rule no longer exists on this item — refresh and try again",
+  bulkTooLarge: `Cannot mark more than ${MAX_BULK_SERVICE_ITEMS} items serviced at once`,
+  suppressedWithThresholds:
+    "A suppressed rule cannot also set thresholds — clear them or turn off suppression",
 };
 
 export function messageForCode(code: string): string {
diff --git a/src/lib/__tests__/dates.test.ts b/src/lib/__tests__/dates.test.ts
new file mode 100644
index 00000000..6f217253
--- /dev/null
+++ b/src/lib/__tests__/dates.test.ts
@@ -0,0 +1,150 @@
+import { afterEach, describe, expect, setSystemTime, test } from "bun:test";
+import {
+  FUTURE_DATE_TOLERANCE_DAYS,
+  ISO_DATE,
+  isRealCalendarDate,
+  todayIso,
+} from "@/src/lib/dates";
+
+/**
+ * Direct coverage for `src/lib/dates.ts` — extracted from four previously
+ * byte-identical copies (firearms' `acquiredDate`, accessories'
+ * `installedDate`, range-sessions' `date`, service-intervals' `servicedOn`).
+ * This file owns the invariant at its source; it does not replace the
+ * indirect coverage still exercised through each consumer's own validator
+ * tests (`src/domain/firearms/__tests__/validate.test.ts`,
+ * `src/domain/accessories/__tests__/validate.test.ts`,
+ * `src/domain/service-intervals/__tests__/validate-event.test.ts`).
+ *
+ * See `docs/solutions/test-failures/timezone-fragile-date-boundary-tests.md`:
+ * calendar-date fixtures are built with `new Date(y, monthIndex, d)` (local
+ * frame), never UTC `...Z` literals, unless a test is deliberately pinning an
+ * absolute instant (as the `todayIso` TZ tests below do via
+ * `setSystemTime`).
+ */
+
+describe("isRealCalendarDate", () => {
+  test("a real calendar date is accepted", () => {
+    expect(isRealCalendarDate("2026-06-15")).toBe(true);
+  });
+
+  test("Feb 29 on a leap year is accepted", () => {
+    expect(isRealCalendarDate("2024-02-29")).toBe(true);
+  });
+
+  test("day-overflow normalization is rejected: Feb 30 (Date.parse silently rolls it to Mar 2)", () => {
+    expect(isRealCalendarDate("2026-02-30")).toBe(false);
+  });
+
+  test("day-overflow normalization is rejected: Feb 29 on a non-leap year (rolls to Mar 1)", () => {
+    expect(isRealCalendarDate("2026-02-29")).toBe(false);
+  });
+
+  test("month-overflow is rejected: month 13", () => {
+    expect(isRealCalendarDate("2026-13-01")).toBe(false);
+  });
+
+  test("year zero is rejected even though Date.parse round-trips it (no year 0 in Postgres's proleptic Gregorian `date`)", () => {
+    expect(isRealCalendarDate("0000-01-01")).toBe(false);
+  });
+
+  test("a malformed, non-date string is rejected", () => {
+    expect(isRealCalendarDate("not-a-date")).toBe(false);
+  });
+
+  test("an empty string is rejected", () => {
+    expect(isRealCalendarDate("")).toBe(false);
+  });
+});
+
+describe("ISO_DATE", () => {
+  test("accepts a well-formed YYYY-MM-DD string", () => {
+    expect(ISO_DATE.test("2026-06-15")).toBe(true);
+  });
+
+  test("rejects single-digit month/day (not zero-padded)", () => {
+    expect(ISO_DATE.test("2026-6-15")).toBe(false);
+  });
+
+  test("rejects a string with no separators", () => {
+    expect(ISO_DATE.test("20260615")).toBe(false);
+  });
+
+  test("rejects a date-time string (this regex matches shape only, not a bare date)", () => {
+    expect(ISO_DATE.test("2026-06-15T00:00:00.000Z")).toBe(false);
+  });
+
+  test("rejects an empty string", () => {
+    expect(ISO_DATE.test("")).toBe(false);
+  });
+});
+
+describe("todayIso", () => {
+  afterEach(() => {
+    // Release the pinned system clock so later tests/files see real time.
+    setSystemTime();
+  });
+
+  test("returns the LOCAL calendar date, not the UTC date, for the current instant", () => {
+    const now = new Date();
+    // Computed from LOCAL getters (getFullYear/getMonth/getDate), matching
+    // what date-fns `format(new Date(), "yyyy-MM-dd")` reads internally —
+    // NOT `toISOString().slice(0, 10)` / UTC getters, which is exactly the
+    // frame mismatch this extraction fixed.
+    const expectedLocal = [
+      now.getFullYear(),
+      String(now.getMonth() + 1).padStart(2, "0"),
+      String(now.getDate()).padStart(2, "0"),
+    ].join("-");
+
+    expect(todayIso()).toBe(expectedLocal);
+  });
+
+  test("is TZ-stable across a UTC day boundary: an instant just before UTC midnight can already be tomorrow (or still yesterday) locally", () => {
+    // Pin an absolute instant (deliberately a UTC literal here — this is
+    // simulating the wall clock/system time itself, not a calendar-date
+    // fixture, so it's the one place in this file an absolute instant is
+    // correct rather than a local-frame `new Date(y, m, d)`).
+    const pinnedInstant = new Date(Date.UTC(2026, 0, 15, 23, 30));
+    setSystemTime(pinnedInstant);
+
+    // The correct answer depends on the runner's TZ (e.g. UTC-5 keeps this
+    // Jan 15 local; UTC+9 rolls it to Jan 16 local) — computed the same way
+    // both times so the assertion is correct under any TZ, including the
+    // required TZ=Asia/Tokyo and TZ=America/New_York runs.
+    const expectedLocal = [
+      pinnedInstant.getFullYear(),
+      String(pinnedInstant.getMonth() + 1).padStart(2, "0"),
+      String(pinnedInstant.getDate()).padStart(2, "0"),
+    ].join("-");
+
+    expect(todayIso()).toBe(expectedLocal);
+    // A UTC-getter-based implementation (the bug this replaced) would return
+    // "2026-01-15" here regardless of TZ; assert we're not that.
+    if (process.env.TZ && process.env.TZ !== "UTC") {
+      const utcDate = pinnedInstant.toISOString().slice(0, 10);
+      // Only meaningfully different from the local date when the runner's TZ
+      // actually straddles this boundary instant differently than UTC does.
+      if (utcDate !== expectedLocal) {
+        expect(todayIso()).not.toBe(utcDate);
+      }
+    }
+  });
+});
+
+describe("FUTURE_DATE_TOLERANCE_DAYS", () => {
+  test("is exactly one day of slack", () => {
+    // Deliberate, not a placeholder: a not-in-the-future check's `asOf`
+    // defaults to the SERVER's own `new Date()`, but the value being
+    // checked is often the SUBMITTER's own local `todayIso()`. No real
+    // timezone runs more than ~26 hours ahead of another, so a genuine local
+    // "today" can read as at most one calendar day ahead of the server's
+    // clock. Without this one day of slack, a submitter east of the server
+    // (e.g. Asia/Tokyo against a UTC server) submitting their own local
+    // today — exactly what `todayIso()` pre-fills into a form by default —
+    // would be rejected as "in the future" for part of every day. Anything
+    // beyond this single day of slack is a genuinely future date and stays
+    // rejected.
+    expect(FUTURE_DATE_TOLERANCE_DAYS).toBe(1);
+  });
+});
diff --git a/src/lib/as-not-found.ts b/src/lib/as-not-found.ts
new file mode 100644
index 00000000..77c31b59
--- /dev/null
+++ b/src/lib/as-not-found.ts
@@ -0,0 +1,19 @@
+import { notFound } from "next/navigation";
+import { NotFoundError } from "@/src/auth/errors";
+
+/**
+ * Shared 404 guard for detail-page loaders that authorize internally (e.g.
+ * `listPhotos`, `listDocuments`, `getItemDueState`, `listItemRules`,
+ * `listServiceHistory`). A page resolves the viewer's permission once, up
+ * front (`getFirearm` / `getAccessory`), then makes further loader calls in
+ * parallel — if access is revoked (or the row is deleted) between that first
+ * check and one of these later calls, the loader throws `NotFoundError` for
+ * the same reason the first check would have. That must surface as the
+ * page's clean 404, not an unhandled 500 from Next's generic error boundary.
+ *
+ * Usage: `someLoader(...).catch(asNotFound)`.
+ */
+export function asNotFound(error: unknown): never {
+  if (error instanceof NotFoundError) notFound();
+  throw error;
+}
diff --git a/src/lib/dates.ts b/src/lib/dates.ts
new file mode 100644
index 00000000..c684cf04
--- /dev/null
+++ b/src/lib/dates.ts
@@ -0,0 +1,64 @@
+/**
+ * Shared calendar-date helpers. Pure — no DB, no Next.js. Used by every
+ * domain validator that accepts a plain `YYYY-MM-DD` string (firearms'
+ * `acquiredDate`, accessories' `installedDate`, range-sessions' `date`,
+ * service-intervals' `servicedOn`) — previously four byte-identical copies,
+ * now defined once here — and by client forms that default a date field to
+ * today (`range-session-form.tsx`, `log-service-form.tsx`).
+ */
+
+import { format } from "date-fns";
+
+/** Matches a `YYYY-MM-DD` string shape; does not by itself confirm the date is real (see `isRealCalendarDate`). */
+export const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+/**
+ * True only for a real calendar date. `Date.parse` NORMALIZES day overflow
+ * (e.g. `2026-02-31` → Mar 3) instead of returning NaN, so a round-trip
+ * compare against the UTC-normalized ISO date is what rejects impossible
+ * days — the Postgres `date` cast would otherwise reject them downstream.
+ * Deliberately NOT reimplemented with a date-fns call: this depends
+ * specifically on `Date.parse`'s overflow-normalization behavior.
+ *
+ * Year zero is rejected explicitly: `Date.parse("0000-01-01")` succeeds and
+ * round-trips to the same string, so the overflow check above lets it
+ * through, but there is no year 0 in the SQL-standard proleptic Gregorian
+ * calendar Postgres's `date` type uses — an unguarded year-0000 value would
+ * pass validation here and fail downstream as a raw, unhandled driver error.
+ */
+export function isRealCalendarDate(date: string): boolean {
+  if (date.startsWith("0000-")) return false;
+  const parsed = Date.parse(date);
+  if (Number.isNaN(parsed)) return false;
+  return new Date(parsed).toISOString().slice(0, 10) === date;
+}
+
+/**
+ * Today's calendar date (KTD5 default), LOCAL time, as `YYYY-MM-DD` — the
+ * default value a date field opens to (`range-session-form.tsx`'s session
+ * date, `log-service-form.tsx`'s serviced-on date). `date-fns`'s `format`
+ * reads local Y/M/D getters directly, verified equivalent to this file's
+ * prior manual offset-subtraction/`toISOString().slice(0,10)` trick across
+ * timezones and date-boundary instants.
+ */
+export function todayIso(): string {
+  return format(new Date(), "yyyy-MM-dd");
+}
+
+/**
+ * Slack allowed, in calendar days, before a submitted date is treated as
+ * genuinely in the future — shared by every not-in-the-future check that
+ * compares a submitted date against the SERVER's clock (service-intervals'
+ * `servicedOn`, firearms' `acquiredDate`).
+ *
+ * A not-in-the-future check's `asOf` defaults to the server's own
+ * `new Date()`, but the submitter's local calendar day is not the server's:
+ * no real timezone runs more than ~26 hours ahead of another, so a
+ * submitter's genuine local "today" can read as at most one calendar day
+ * ahead of the server. Without this slack, a user east of the server (say,
+ * Tokyo against a UTC server) submitting their own local today — exactly
+ * what `todayIso()` pre-fills into a form by default — would be rejected as
+ * "in the future" for part of every day. Anything beyond this one day of
+ * slack is a real future date and stays rejected.
+ */
+export const FUTURE_DATE_TOLERANCE_DAYS = 1;
diff --git a/src/test-support/factories.ts b/src/test-support/factories.ts
index 4cd7948c..af6e9ef7 100644
--- a/src/test-support/factories.ts
+++ b/src/test-support/factories.ts
@@ -12,9 +12,21 @@ import {
   magazine,
   magazineFirearm,
   rangeSession,
+  serviceEvent,
+  serviceRule,
+  serviceRuleDefault,
   user,
 } from "@/src/db/schema";
 
+/**
+ * `service_rule` and `service_event` each attach to exactly one of a firearm
+ * or an accessory (KTD2) — narrower than `ParentType`
+ * (`@/src/auth/visibility`), which excludes accessory (it isn't a grantable
+ * parent type). Callers pass one variant; the factory spreads it onto the
+ * insert alongside the other fixed defaults.
+ */
+type ServiceParent = { firearmId: string } | { accessoryId: string };
+
 /**
  * DB factories for integration tests (U4+). Each test creates isolated users
  * (random ids) and tears them down via `deleteUsers`, whose ON DELETE CASCADE
@@ -188,6 +200,91 @@ export async function makeFirearmPhoto(
   return row;
 }
 
+/**
+ * Insert a service-rule-default row directly (service-intervals plan, U1).
+ * Owner-scoped configuration, no parent item — defaults to a firearm-scope
+ * "rifle" category "Cleaning" rule with a single rounds threshold, since at
+ * least one threshold must be set (R2).
+ */
+export async function makeServiceRuleDefault(
+  ownerId: string,
+  overrides: Partial<
+    Omit<typeof serviceRuleDefault.$inferInsert, "ownerId">
+  > = {},
+): Promise<typeof serviceRuleDefault.$inferSelect> {
+  const [row] = await db
+    .insert(serviceRuleDefault)
+    .values({
+      scope: "firearm",
+      category: "rifle",
+      name: "Cleaning",
+      intervalRounds: 500,
+      ...overrides,
+      ownerId,
+    })
+    .returning();
+  return row;
+}
+
+/**
+ * Insert a service-rule row directly (service-intervals plan, U1). `parent`
+ * carries exactly one of `firearmId`/`accessoryId` (KTD2); `overrides`
+ * excludes both so a caller can't accidentally attach the row to a different
+ * parent than the one passed explicitly. Defaults to an unsuppressed
+ * "Cleaning" rule with a single rounds threshold.
+ */
+export async function makeServiceRule(
+  parent: ServiceParent,
+  overrides: Partial<
+    Omit<typeof serviceRule.$inferInsert, "firearmId" | "accessoryId">
+  > = {},
+): Promise<typeof serviceRule.$inferSelect> {
+  const suppressed = overrides.suppressed ?? false;
+  const [row] = await db
+    .insert(serviceRule)
+    .values({
+      name: "Cleaning",
+      intervalRounds: 500,
+      ...overrides,
+      // A suppressed rule must carry no thresholds (DB CHECK
+      // `service_rule_suppressed_thresholds_consistent`) — force them null
+      // here so callers don't have to remember to null all three
+      // themselves, and so the constraint failure can't turn into an opaque
+      // Postgres error instead of the intended row shape.
+      ...(suppressed
+        ? { intervalDays: null, intervalSessions: null, intervalRounds: null }
+        : {}),
+      ...parent,
+    })
+    .returning();
+  return row;
+}
+
+/**
+ * Insert a service-event row directly (service-intervals plan, U1). `parent`
+ * carries exactly one of `firearmId`/`accessoryId` (KTD2), matching
+ * `makeServiceRule`. `actorId` is a nullable FK (`ON DELETE SET NULL`), so
+ * unlike `makeLogEntry` it has no required override — omit it to test the
+ * "acting user later deleted" case directly.
+ */
+export async function makeServiceEvent(
+  parent: ServiceParent,
+  overrides: Partial<
+    Omit<typeof serviceEvent.$inferInsert, "firearmId" | "accessoryId">
+  > = {},
+): Promise<typeof serviceEvent.$inferSelect> {
+  const [row] = await db
+    .insert(serviceEvent)
+    .values({
+      ruleName: "Cleaning",
+      servicedOn: "2026-01-01",
+      ...overrides,
+      ...parent,
+    })
+    .returning();
+  return row;
+}
+
 /**
  * Insert an inventory-log row directly (U5). `actor_id` is a real FK to `user`
  * (`ON DELETE SET NULL`), so callers must always supply a valid user id via