diff --git a/apps/api/src/server.integration.test.ts b/apps/api/src/server.integration.test.ts
index ed867e7..b8fa680 100644
--- a/apps/api/src/server.integration.test.ts
+++ b/apps/api/src/server.integration.test.ts
@@ -3843,7 +3843,7 @@ describe("@runroot/api integration", () => {
     }
   });
 
-  it("serves acknowledge, list-acknowledged, inspect-acknowledgment, clear-acknowledgment, and apply paths through the network API", async () => {
+  it("serves acknowledgment and sign-off list, inspect, clear, and apply paths through the network API", async () => {
     const workspaceRoot = await mkdtemp(
       join(tmpdir(), "runroot-api-checklist-acknowledgment-"),
     );
@@ -4158,21 +4158,58 @@ describe("@runroot/api integration", () => {
           method: "POST",
         },
       );
+      const signoffResponse = await fetch(
+        `${ownerAddress}/audit/catalog/${publishedPayload.catalogEntry.entry.id}/sign-off`,
+        {
+          body: JSON.stringify({
+            signoffNote: "Backup signed off the acknowledged follow-up",
+            items: [
+              {
+                item: "Validate queued follow-up",
+                state: "signed-off",
+              },
+              {
+                item: "Close backup handoff",
+                state: "unsigned",
+              },
+            ],
+          }),
+          headers: {
+            "content-type": "application/json",
+          },
+          method: "POST",
+        },
+      );
       const acknowledgedResponse = await fetch(
         `${peerAddress}/audit/catalog/acknowledged`,
       );
+      const signedOffResponse = await fetch(
+        `${peerAddress}/audit/catalog/signed-off`,
+      );
       const inspectResponse = await fetch(
         `${peerAddress}/audit/catalog/${publishedPayload.catalogEntry.entry.id}/acknowledgment`,
       );
+      const inspectSignoffResponse = await fetch(
+        `${peerAddress}/audit/catalog/${publishedPayload.catalogEntry.entry.id}/sign-off`,
+      );
       const applyResponse = await fetch(
         `${peerAddress}/audit/catalog/${publishedPayload.catalogEntry.entry.id}/apply`,
       );
+      const clearSignoffResponse = await fetch(
+        `${ownerAddress}/audit/catalog/${publishedPayload.catalogEntry.entry.id}/sign-off/clear`,
+        {
+          method: "POST",
+        },
+      );
       const clearResponse = await fetch(
         `${ownerAddress}/audit/catalog/${publishedPayload.catalogEntry.entry.id}/acknowledgment/clear`,
         {
           method: "POST",
         },
       );
+      const signedOffAfterClearResponse = await fetch(
+        `${peerAddress}/audit/catalog/signed-off`,
+      );
       const acknowledgedAfterClearResponse = await fetch(
         `${peerAddress}/audit/catalog/acknowledged`,
       );
@@ -4202,6 +4239,27 @@ describe("@runroot/api integration", () => {
           };
         };
       };
+      const signoffPayload = (await signoffResponse.json()) as {
+        signoff: {
+          acknowledgment: {
+            acknowledgment: {
+              acknowledgmentNote?: string;
+            };
+            attestation: {
+              attestation: {
+                attestationNote?: string;
+              };
+            };
+          };
+          signoff: {
+            signoffNote?: string;
+            items: Array<{
+              item: string;
+              state: "signed-off" | "unsigned";
+            }>;
+          };
+        };
+      };
       const acknowledgedPayload = (await acknowledgedResponse.json()) as {
         acknowledged: {
           items: Array<{
@@ -4237,6 +4295,43 @@ describe("@runroot/api integration", () => {
           totalCount: number;
         };
       };
+      const signedOffPayload = (await signedOffResponse.json()) as {
+        signedOff: {
+          items: Array<{
+            acknowledgment: {
+              attestation: {
+                evidence: {
+                  verification: {
+                    resolution: {
+                      blocker: {
+                        progress: {
+                          checklist: {
+                            assignment: {
+                              review: {
+                                visibility: {
+                                  catalogEntry: {
+                                    entry: {
+                                      id: string;
+                                    };
+                                  };
+                                };
+                              };
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+            signoff: {
+              signoffNote?: string;
+            };
+          }>;
+          totalCount: number;
+        };
+      };
       const inspectPayload = (await inspectResponse.json()) as {
         acknowledgment: {
           acknowledgment: {
@@ -4248,6 +4343,17 @@ describe("@runroot/api integration", () => {
           };
         };
       };
+      const inspectSignoffPayload = (await inspectSignoffResponse.json()) as {
+        signoff: {
+          signoff: {
+            signoffNote?: string;
+            items: Array<{
+              item: string;
+              state: "signed-off" | "unsigned";
+            }>;
+          };
+        };
+      };
       const applyPayload = (await applyResponse.json()) as {
         application: {
           application: {
@@ -4265,6 +4371,13 @@ describe("@runroot/api integration", () => {
           };
         };
       };
+      const clearSignoffPayload = (await clearSignoffResponse.json()) as {
+        signoff: {
+          signoff: {
+            signoffNote?: string;
+          };
+        };
+      };
       const clearPayload = (await clearResponse.json()) as {
         acknowledgment: {
           acknowledgment: {
@@ -4272,6 +4385,12 @@ describe("@runroot/api integration", () => {
           };
         };
       };
+      const signedOffAfterClearPayload =
+        (await signedOffAfterClearResponse.json()) as {
+          signedOff: {
+            totalCount: number;
+          };
+        };
       const acknowledgedAfterClearPayload =
         (await acknowledgedAfterClearResponse.json()) as {
           acknowledged: {
@@ -4292,6 +4411,7 @@ describe("@runroot/api integration", () => {
       expect(evidenceResponse.status).toBe(200);
       expect(attestationResponse.status).toBe(200);
       expect(acknowledgmentResponse.status).toBe(200);
+      expect(signoffResponse.status).toBe(200);
       expect(
         acknowledgmentPayload.acknowledgment.attestation.evidence.verification
           .verification.verificationNote,
@@ -4319,6 +4439,26 @@ describe("@runroot/api integration", () => {
           },
         ],
       );
+      expect(
+        signoffPayload.signoff.acknowledgment.acknowledgment.acknowledgmentNote,
+      ).toBe("Backup acknowledged the attested follow-up");
+      expect(
+        signoffPayload.signoff.acknowledgment.attestation.attestation
+          .attestationNote,
+      ).toBe("Backup attested the stable follow-up evidence");
+      expect(signoffPayload.signoff.signoff.signoffNote).toBe(
+        "Backup signed off the acknowledged follow-up",
+      );
+      expect(signoffPayload.signoff.signoff.items).toEqual([
+        {
+          item: "Validate queued follow-up",
+          state: "signed-off",
+        },
+        {
+          item: "Close backup handoff",
+          state: "unsigned",
+        },
+      ]);
       expect(acknowledgedResponse.status).toBe(200);
       expect(acknowledgedPayload.acknowledged.totalCount).toBe(1);
       expect(
@@ -4326,10 +4466,34 @@ describe("@runroot/api integration", () => {
           .verification.resolution.blocker.progress.checklist.assignment.review
           .visibility.catalogEntry.entry.id,
       ).toBe("catalog_entry_acknowledgment_api");
+      expect(signedOffResponse.status).toBe(200);
+      expect(signedOffPayload.signedOff.totalCount).toBe(1);
+      expect(
+        signedOffPayload.signedOff.items[0]?.acknowledgment.attestation.evidence
+          .verification.resolution.blocker.progress.checklist.assignment.review
+          .visibility.catalogEntry.entry.id,
+      ).toBe("catalog_entry_acknowledgment_api");
+      expect(signedOffPayload.signedOff.items[0]?.signoff.signoffNote).toBe(
+        "Backup signed off the acknowledged follow-up",
+      );
       expect(inspectResponse.status).toBe(200);
       expect(
         inspectPayload.acknowledgment.acknowledgment.acknowledgmentNote,
       ).toBe("Backup acknowledged the attested follow-up");
+      expect(inspectSignoffResponse.status).toBe(200);
+      expect(inspectSignoffPayload.signoff.signoff.signoffNote).toBe(
+        "Backup signed off the acknowledged follow-up",
+      );
+      expect(inspectSignoffPayload.signoff.signoff.items).toEqual([
+        {
+          item: "Validate queued follow-up",
+          state: "signed-off",
+        },
+        {
+          item: "Close backup handoff",
+          state: "unsigned",
+        },
+      ]);
       expect(applyResponse.status).toBe(200);
       expect(applyPayload.application.application.savedView.id).toBe(
         "saved_view_acknowledgment_api",
@@ -4338,10 +4502,16 @@ describe("@runroot/api integration", () => {
         applyPayload.application.application.navigation.drilldowns[0]?.result
           .runId,
       ).toBe(queuedRun.id);
+      expect(clearSignoffResponse.status).toBe(200);
+      expect(clearSignoffPayload.signoff.signoff.signoffNote).toBe(
+        "Backup signed off the acknowledged follow-up",
+      );
       expect(clearResponse.status).toBe(200);
       expect(
         clearPayload.acknowledgment.acknowledgment.acknowledgmentNote,
       ).toBe("Backup acknowledged the attested follow-up");
+      expect(signedOffAfterClearResponse.status).toBe(200);
+      expect(signedOffAfterClearPayload.signedOff.totalCount).toBe(0);
       expect(acknowledgedAfterClearResponse.status).toBe(200);
       expect(acknowledgedAfterClearPayload.acknowledged.totalCount).toBe(0);
     } finally {
diff --git a/apps/api/src/server.test.ts b/apps/api/src/server.test.ts
index 5a1b448..fabdf0d 100644
--- a/apps/api/src/server.test.ts
+++ b/apps/api/src/server.test.ts
@@ -25,7 +25,7 @@ describe("@runroot/api", () => {
     expect(response.json()).toEqual({
       status: "ok",
       project: "Runroot",
-      phase: 27,
+      phase: 28,
     });
   });
 
diff --git a/apps/api/src/server.ts b/apps/api/src/server.ts
index c61b7b0..80bf416 100644
--- a/apps/api/src/server.ts
+++ b/apps/api/src/server.ts
@@ -285,6 +285,12 @@ export function buildServer(options: BuildServerOptions = {}) {
     })),
   );
 
+  app.get("/audit/catalog/signed-off", async (_request, reply) =>
+    handleOperatorResponse(reply, async () => ({
+      signedOff: await operator.listSignedOffCatalogEntries(),
+    })),
+  );
+
   app.post("/audit/saved-views", async (request, reply) =>
     handleOperatorResponse(reply, async () => {
       const body = request.body as {
@@ -534,6 +540,20 @@ export function buildServer(options: BuildServerOptions = {}) {
       }),
   );
 
+  app.get("/audit/catalog/:catalogEntryId/sign-off", async (request, reply) =>
+    handleOperatorResponse(reply, async () => {
+      const params = request.params as {
+        readonly catalogEntryId: string;
+      };
+
+      return {
+        signoff: await operator.getCatalogChecklistItemSignoff(
+          params.catalogEntryId,
+        ),
+      };
+    }),
+  );
+
   app.get("/audit/catalog/:catalogEntryId", async (request, reply) =>
     handleOperatorResponse(reply, async () => {
       const params = request.params as {
@@ -870,6 +890,34 @@ export function buildServer(options: BuildServerOptions = {}) {
       }),
   );
 
+  app.post("/audit/catalog/:catalogEntryId/sign-off", async (request, reply) =>
+    handleOperatorResponse(reply, async () => {
+      const params = request.params as {
+        readonly catalogEntryId: string;
+      };
+      const body = request.body as {
+        readonly signoffNote?: string;
+        readonly items?: unknown;
+      };
+      const items = readChecklistItemSignoffItems(body?.items, "items");
+
+      if (items.length === 0) {
+        throw new OperatorInputError(
+          "items must include at least one checklist item signoff entry.",
+        );
+      }
+
+      return {
+        signoff: await operator.signOffCatalogEntry(params.catalogEntryId, {
+          ...(body?.signoffNote !== undefined
+            ? { signoffNote: body.signoffNote }
+            : {}),
+          items,
+        }),
+      };
+    }),
+  );
+
   app.post(
     "/audit/catalog/:catalogEntryId/review/clear",
     async (request, reply) =>
@@ -1031,6 +1079,22 @@ export function buildServer(options: BuildServerOptions = {}) {
       }),
   );
 
+  app.post(
+    "/audit/catalog/:catalogEntryId/sign-off/clear",
+    async (request, reply) =>
+      handleOperatorResponse(reply, async () => {
+        const params = request.params as {
+          readonly catalogEntryId: string;
+        };
+
+        return {
+          signoff: await operator.clearCatalogChecklistItemSignoff(
+            params.catalogEntryId,
+          ),
+        };
+      }),
+  );
+
   app.get("/audit/saved-views/:savedViewId/apply", async (request, reply) =>
     handleOperatorResponse(reply, async () => {
       const params = request.params as {
@@ -1598,3 +1662,30 @@ function readChecklistItemAcknowledgmentItems(
 
   return value;
 }
+
+function readChecklistItemSignoffItems(
+  value: unknown,
+  fieldName: string,
+): readonly {
+  readonly item: string;
+  readonly state: "signed-off" | "unsigned";
+}[] {
+  if (
+    !Array.isArray(value) ||
+    !value.every(
+      (entry) =>
+        typeof entry === "object" &&
+        entry !== null &&
+        "item" in entry &&
+        typeof entry.item === "string" &&
+        "state" in entry &&
+        (entry.state === "signed-off" || entry.state === "unsigned"),
+    )
+  ) {
+    throw new OperatorInputError(
+      `${fieldName} must be an array of { item, state } objects with state signed-off|unsigned.`,
+    );
+  }
+
+  return value;
+}
diff --git a/apps/web/src/app/runs/catalog/route.ts b/apps/web/src/app/runs/catalog/route.ts
index c1c276c..9f41d90 100644
--- a/apps/web/src/app/runs/catalog/route.ts
+++ b/apps/web/src/app/runs/catalog/route.ts
@@ -551,6 +551,53 @@ export async function POST(request: Request) {
       return Response.redirect(redirectUrl, 303);
     }
 
+    if (intent === "sign-off") {
+      const catalogEntryId = readTrimmedFormValue(formData, "catalogEntryId");
+      const signoffItems = readChecklistItemSignoffItems(
+        formData.get("signoffItems"),
+      );
+      const signoffNoteValue = formData.get("signoffNote");
+
+      if (!catalogEntryId) {
+        appendFlashMessage(
+          redirectUrl,
+          "error",
+          "A catalog entry id is required to update checklist item sign-off metadata.",
+        );
+
+        return Response.redirect(redirectUrl, 303);
+      }
+
+      if (signoffItems.length === 0) {
+        appendFlashMessage(
+          redirectUrl,
+          "error",
+          "At least one checklist item sign-off entry is required.",
+        );
+
+        return Response.redirect(redirectUrl, 303);
+      }
+
+      const signoff =
+        await createRunrootApiClient().setAuditCatalogChecklistItemSignoff(
+          catalogEntryId,
+          {
+            ...(typeof signoffNoteValue === "string"
+              ? { signoffNote: signoffNoteValue }
+              : {}),
+            items: signoffItems,
+          },
+        );
+
+      appendFlashMessage(
+        redirectUrl,
+        "notice",
+        `Checklist item sign-offs for ${signoff.acknowledgment.attestation.evidence.verification.resolution.blocker.progress.checklist.assignment.review.visibility.catalogEntry.entry.name} updated.`,
+      );
+
+      return Response.redirect(redirectUrl, 303);
+    }
+
     if (intent === "clear-review") {
       const catalogEntryId = readTrimmedFormValue(formData, "catalogEntryId");
 
@@ -767,6 +814,33 @@ export async function POST(request: Request) {
       return Response.redirect(redirectUrl, 303);
     }
 
+    if (intent === "clear-sign-off") {
+      const catalogEntryId = readTrimmedFormValue(formData, "catalogEntryId");
+
+      if (!catalogEntryId) {
+        appendFlashMessage(
+          redirectUrl,
+          "error",
+          "A catalog entry id is required to clear checklist item sign-off metadata.",
+        );
+
+        return Response.redirect(redirectUrl, 303);
+      }
+
+      const signoff =
+        await createRunrootApiClient().clearAuditCatalogChecklistItemSignoff(
+          catalogEntryId,
+        );
+
+      appendFlashMessage(
+        redirectUrl,
+        "notice",
+        `Checklist item sign-offs for ${signoff.acknowledgment.attestation.evidence.verification.resolution.blocker.progress.checklist.assignment.review.visibility.catalogEntry.entry.name} cleared.`,
+      );
+
+      return Response.redirect(redirectUrl, 303);
+    }
+
     if (intent === "clear-progress") {
       const catalogEntryId = readTrimmedFormValue(formData, "catalogEntryId");
 
@@ -1216,3 +1290,49 @@ function readChecklistItemAcknowledgmentItems(
       };
     });
 }
+
+function readChecklistItemSignoffItems(
+  value: FormDataEntryValue | null,
+): readonly {
+  readonly item: string;
+  readonly state: "signed-off" | "unsigned";
+}[] {
+  if (typeof value !== "string") {
+    return [];
+  }
+
+  return value
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => {
+      const separatorIndex = line.indexOf(":");
+
+      if (separatorIndex < 0) {
+        return {
+          item: line,
+          state: "unsigned" as const,
+        };
+      }
+
+      const rawState = line.slice(0, separatorIndex).trim();
+      const item = line.slice(separatorIndex + 1).trim();
+
+      if (item.length === 0) {
+        throw new Error(
+          "Checklist item sign-off lines require a non-empty item.",
+        );
+      }
+
+      if (rawState !== "signed-off" && rawState !== "unsigned") {
+        throw new Error(
+          `Checklist item sign-off state must be signed-off or unsigned for "${item}".`,
+        );
+      }
+
+      return {
+        item,
+        state: rawState,
+      };
+    });
+}
diff --git a/apps/web/src/app/runs/page.tsx b/apps/web/src/app/runs/page.tsx
index 6c4efeb..1c8d878 100644
--- a/apps/web/src/app/runs/page.tsx
+++ b/apps/web/src/app/runs/page.tsx
@@ -9,6 +9,7 @@ import {
   ChecklistItemEvidencesView,
   ChecklistItemProgressView,
   ChecklistItemResolutionsView,
+  ChecklistItemSignoffsView,
   ChecklistItemVerificationsView,
   ConsoleShell,
   CrossRunAuditNavigationView,
@@ -30,6 +31,7 @@ import {
   type ApiAuditCatalogChecklistItemEvidenceView,
   type ApiAuditCatalogChecklistItemProgressView,
   type ApiAuditCatalogChecklistItemResolutionView,
+  type ApiAuditCatalogChecklistItemSignoffView,
   type ApiAuditCatalogChecklistItemVerificationView,
   type ApiAuditCatalogEntryApplication,
   type ApiAuditCatalogReviewAssignmentView,
@@ -64,6 +66,7 @@ export default async function RunsPage({
     const drilldownFilters = readAuditDrilldownFilters(resolvedSearchParams);
     const [
       runs,
+      signedOffEntries,
       acknowledgedEntries,
       blockedEntries,
       evidencedEntries,
@@ -81,6 +84,7 @@ export default async function RunsPage({
       catalogChecklistItemBlocker,
       catalogChecklistItemResolution,
       catalogChecklistItemEvidence,
+      catalogChecklistItemSignoff,
       catalogChecklistItemAcknowledgment,
       catalogChecklistItemAttestation,
       catalogChecklistItemVerification,
@@ -90,6 +94,7 @@ export default async function RunsPage({
       catalogReviewAssignment,
     ] = await Promise.all([
       api.listRuns(),
+      api.listSignedOffAuditCatalogEntries(),
       api.listAcknowledgedAuditCatalogEntries(),
       api.listBlockedAuditCatalogEntries(),
       api.listEvidencedAuditCatalogEntries(),
@@ -128,6 +133,11 @@ export default async function RunsPage({
             .getAuditCatalogChecklistItemEvidence(catalogEntryId)
             .catch(() => undefined)
         : Promise.resolve(undefined),
+      catalogEntryId
+        ? api
+            .getAuditCatalogChecklistItemSignoff(catalogEntryId)
+            .catch(() => undefined)
+        : Promise.resolve(undefined),
       catalogEntryId
         ? api
             .getAuditCatalogChecklistItemAcknowledgment(catalogEntryId)
@@ -176,6 +186,9 @@ export default async function RunsPage({
     let activeCatalogChecklistItemEvidence:
       | ApiAuditCatalogChecklistItemEvidenceView
       | undefined;
+    let activeCatalogChecklistItemSignoff:
+      | ApiAuditCatalogChecklistItemSignoffView
+      | undefined;
     let activeCatalogChecklistItemAcknowledgment:
       | ApiAuditCatalogChecklistItemAcknowledgmentView
       | undefined;
@@ -200,6 +213,7 @@ export default async function RunsPage({
       activeCatalogChecklistItemBlocker = catalogChecklistItemBlocker;
       activeCatalogChecklistItemResolution = catalogChecklistItemResolution;
       activeCatalogChecklistItemEvidence = catalogChecklistItemEvidence;
+      activeCatalogChecklistItemSignoff = catalogChecklistItemSignoff;
       activeCatalogChecklistItemAcknowledgment =
         catalogChecklistItemAcknowledgment;
       activeCatalogChecklistItemAttestation = catalogChecklistItemAttestation;
@@ -241,6 +255,12 @@ export default async function RunsPage({
             ? { activeCatalogChecklistItemEvidence }
             : {})}
         />
+        <ChecklistItemSignoffsView
+          signedOffEntries={signedOffEntries}
+          {...(activeCatalogChecklistItemSignoff
+            ? { activeCatalogChecklistItemSignoff }
+            : {})}
+        />
         <ChecklistItemAcknowledgmentsView
           acknowledgedEntries={acknowledgedEntries}
           {...(activeCatalogChecklistItemAcknowledgment
@@ -287,6 +307,7 @@ export default async function RunsPage({
           catalogEntries={catalogEntries}
           checklistedEntries={checklistedEntries}
           evidencedEntries={evidencedEntries}
+          signedOffEntries={signedOffEntries}
           acknowledgedEntries={acknowledgedEntries}
           attestedEntries={attestedEntries}
           progressedEntries={progressedEntries}
@@ -303,6 +324,9 @@ export default async function RunsPage({
           {...(activeCatalogChecklistItemEvidence
             ? { activeCatalogChecklistItemEvidence }
             : {})}
+          {...(activeCatalogChecklistItemSignoff
+            ? { activeCatalogChecklistItemSignoff }
+            : {})}
           {...(activeCatalogChecklistItemAcknowledgment
             ? { activeCatalogChecklistItemAcknowledgment }
             : {})}
diff --git a/apps/web/src/app/web.integration.test.tsx b/apps/web/src/app/web.integration.test.tsx
index 1536702..ec695e7 100644
--- a/apps/web/src/app/web.integration.test.tsx
+++ b/apps/web/src/app/web.integration.test.tsx
@@ -2727,7 +2727,7 @@ describe("@runroot/web integration", () => {
     }
   });
 
-  it("renders, records, clears, and reapplies checklist item acknowledgments through the existing API surface", async () => {
+  it("renders, records, clears, and reapplies checklist item acknowledgments and sign-offs through the existing API surface", async () => {
     const workspaceRoot = await mkdtemp(
       join(tmpdir(), "runroot-web-checklist-acknowledgment-"),
     );
@@ -3086,9 +3086,34 @@ describe("@runroot/web integration", () => {
 
       expect(acknowledgmentResponse.status).toBe(303);
 
+      const signoffForm = new FormData();
+      signoffForm.set("catalogEntryId", "catalog_entry_acknowledgment_web");
+      signoffForm.set("intent", "sign-off");
+      signoffForm.set(
+        "signoffItems",
+        "signed-off: Validate queued follow-up\nunsigned: Close backup handoff",
+      );
+      signoffForm.set(
+        "signoffNote",
+        "Backup signed off the acknowledged follow-up",
+      );
+      signoffForm.set(
+        "returnTo",
+        "/runs?catalogEntryId=catalog_entry_acknowledgment_web",
+      );
+
+      const signoffResponse = await mutateCatalog(
+        new Request("http://localhost/runs/catalog", {
+          body: signoffForm,
+          method: "POST",
+        }),
+      );
+
+      expect(signoffResponse.status).toBe(303);
+
       process.env.RUNROOT_API_BASE_URL = peerAddress;
 
-      const acknowledgedMarkup = renderToStaticMarkup(
+      const signedOffMarkup = renderToStaticMarkup(
         await RunsPage({
           searchParams: Promise.resolve({
             catalogEntryId: "catalog_entry_acknowledgment_web",
@@ -3096,19 +3121,64 @@ describe("@runroot/web integration", () => {
         }),
       );
 
-      expect(acknowledgedMarkup).toContain("Checklist item acknowledgments");
-      expect(acknowledgedMarkup).toContain("Queued acknowledgment preset");
-      expect(acknowledgedMarkup).toContain("1/2 acknowledged");
-      expect(acknowledgedMarkup).toContain("Validate queued follow-up");
-      expect(acknowledgedMarkup).toContain("Close backup handoff");
-      expect(acknowledgedMarkup).toContain(
+      expect(signedOffMarkup).toContain("Checklist item acknowledgments");
+      expect(signedOffMarkup).toContain("Queued acknowledgment preset");
+      expect(signedOffMarkup).toContain("1/2 acknowledged");
+      expect(signedOffMarkup).toContain("Validate queued follow-up");
+      expect(signedOffMarkup).toContain("Close backup handoff");
+      expect(signedOffMarkup).toContain(
         "Backup acknowledged the attested follow-up",
       );
-      expect(acknowledgedMarkup).toContain("Apply acknowledged preset");
-      expect(acknowledgedMarkup).toContain(
+      expect(signedOffMarkup).toContain("Apply acknowledged preset");
+      expect(signedOffMarkup).toContain(
         `Queued worker ${queuedRun.id} handed to backup`,
       );
-      expect(acknowledgedMarkup).toContain("Active acknowledgments selected");
+      expect(signedOffMarkup).toContain("Active acknowledgments selected");
+      expect(signedOffMarkup).toContain("Checklist item sign-offs");
+      expect(signedOffMarkup).toContain("1/2 signed off");
+      expect(signedOffMarkup).toContain(
+        "Backup signed off the acknowledged follow-up",
+      );
+      expect(signedOffMarkup).toContain("Apply signed-off preset");
+      expect(signedOffMarkup).toContain("Active sign-offs selected");
+
+      process.env.RUNROOT_API_BASE_URL = ownerAddress;
+
+      const clearSignoffForm = new FormData();
+      clearSignoffForm.set(
+        "catalogEntryId",
+        "catalog_entry_acknowledgment_web",
+      );
+      clearSignoffForm.set("intent", "clear-sign-off");
+      clearSignoffForm.set(
+        "returnTo",
+        "/runs?catalogEntryId=catalog_entry_acknowledgment_web",
+      );
+
+      const clearSignoffResponse = await mutateCatalog(
+        new Request("http://localhost/runs/catalog", {
+          body: clearSignoffForm,
+          method: "POST",
+        }),
+      );
+
+      expect(clearSignoffResponse.status).toBe(303);
+
+      process.env.RUNROOT_API_BASE_URL = peerAddress;
+
+      const clearedSignoffMarkup = renderToStaticMarkup(
+        await RunsPage({
+          searchParams: Promise.resolve({
+            catalogEntryId: "catalog_entry_acknowledgment_web",
+          }),
+        }),
+      );
+
+      expect(clearedSignoffMarkup).toContain("Checklist item sign-offs");
+      expect(clearedSignoffMarkup).toContain("No checklist item sign-offs yet");
+      expect(clearedSignoffMarkup).not.toContain(
+        "Backup signed off the acknowledged follow-up",
+      );
 
       process.env.RUNROOT_API_BASE_URL = ownerAddress;
 
diff --git a/apps/web/src/components/console.tsx b/apps/web/src/components/console.tsx
index 6db2d9d..11d6e24 100644
--- a/apps/web/src/components/console.tsx
+++ b/apps/web/src/components/console.tsx
@@ -22,6 +22,9 @@ import type {
   ApiAuditCatalogChecklistItemResolutionCollection,
   ApiAuditCatalogChecklistItemResolutionItem,
   ApiAuditCatalogChecklistItemResolutionView,
+  ApiAuditCatalogChecklistItemSignoffCollection,
+  ApiAuditCatalogChecklistItemSignoffItem,
+  ApiAuditCatalogChecklistItemSignoffView,
   ApiAuditCatalogChecklistItemVerificationCollection,
   ApiAuditCatalogChecklistItemVerificationItem,
   ApiAuditCatalogChecklistItemVerificationView,
@@ -1378,6 +1381,157 @@ export function ChecklistItemAcknowledgmentsView({
   );
 }
 
+export function ChecklistItemSignoffsView({
+  activeCatalogChecklistItemSignoff,
+  signedOffEntries,
+}: Readonly<{
+  activeCatalogChecklistItemSignoff?: ApiAuditCatalogChecklistItemSignoffView;
+  signedOffEntries: ApiAuditCatalogChecklistItemSignoffCollection;
+}>) {
+  return (
+    <section className="card">
+      <div className="row spread">
+        <div>
+          <div className="card-eyebrow">
+            Phase 28 / Checklist Item Sign-Offs
+          </div>
+          <h2>Checklist item sign-offs</h2>
+          <p className="empty-copy">
+            Track thin per-item sign-offs and a single sign-off note on
+            acknowledged presets without turning the console into an approval
+            product, workflow engine, or collaboration surface.
+          </p>
+        </div>
+        <div className="timeline-count">
+          {signedOffEntries.totalCount} signed-off preset(s)
+        </div>
+      </div>
+
+      {activeCatalogChecklistItemSignoff ? (
+        <div className="inline-note">
+          Active sign-offs:{" "}
+          <strong>
+            {
+              activeCatalogChecklistItemSignoff.acknowledgment.attestation
+                .evidence.verification.resolution.blocker.progress.checklist
+                .assignment.review.visibility.catalogEntry.entry.name
+            }
+          </strong>
+          {" · "}
+          {formatSignoffSummary(
+            activeCatalogChecklistItemSignoff.signoff.items,
+          )}
+          {activeCatalogChecklistItemSignoff.signoff.signoffNote
+            ? ` · ${activeCatalogChecklistItemSignoff.signoff.signoffNote}`
+            : ""}
+        </div>
+      ) : null}
+
+      {signedOffEntries.items.length === 0 ? (
+        <p className="empty-copy">
+          No checklist item sign-offs yet. Record acknowledgments first, then
+          save thin sign-off metadata through the shared operator seam.
+        </p>
+      ) : (
+        <ol className="timeline-list">
+          {signedOffEntries.items.map((signoffView) => (
+            <li
+              className="timeline-entry"
+              key={
+                signoffView.acknowledgment.attestation.evidence.verification
+                  .resolution.blocker.progress.checklist.assignment.review
+                  .visibility.catalogEntry.entry.id
+              }
+            >
+              <div className="row spread">
+                <div>
+                  <strong>
+                    {
+                      signoffView.acknowledgment.attestation.evidence
+                        .verification.resolution.blocker.progress.checklist
+                        .assignment.review.visibility.catalogEntry.entry.name
+                    }
+                  </strong>
+                  <div className="timeline-meta">
+                    {formatSignoffSummary(signoffView.signoff.items)}
+                    {" · "}
+                    {formatAcknowledgmentSummary(
+                      signoffView.acknowledgment.acknowledgment.items,
+                    )}
+                    {" · "}
+                    {formatAttestationSummary(
+                      signoffView.acknowledgment.attestation.attestation.items,
+                    )}
+                  </div>
+                </div>
+                <span>{formatTimestamp(signoffView.signoff.updatedAt)}</span>
+              </div>
+              <ul className="approval-history">
+                {signoffView.signoff.items.map((item) => (
+                  <li
+                    key={`${signoffView.signoff.catalogEntryId}:${item.item}`}
+                  >
+                    <strong>{item.state}</strong>: {item.item}
+                  </li>
+                ))}
+              </ul>
+              {signoffView.signoff.signoffNote ? (
+                <p className="empty-copy">{signoffView.signoff.signoffNote}</p>
+              ) : null}
+              <div className="timeline-meta">
+                operator {signoffView.signoff.operatorId} · scope{" "}
+                {signoffView.signoff.scopeId}
+              </div>
+              <div className="row spread">
+                <a
+                  className="link-button"
+                  href={buildCatalogEntryHref(
+                    signoffView.acknowledgment.attestation.evidence.verification
+                      .resolution.blocker.progress.checklist.assignment.review
+                      .visibility.catalogEntry.entry.id,
+                  )}
+                >
+                  Apply signed-off preset
+                </a>
+                <form
+                  action="/runs/catalog"
+                  className="action-form"
+                  method="post"
+                >
+                  <input
+                    name="returnTo"
+                    type="hidden"
+                    value={buildCatalogEntryHref(
+                      signoffView.acknowledgment.attestation.evidence
+                        .verification.resolution.blocker.progress.checklist
+                        .assignment.review.visibility.catalogEntry.entry.id,
+                    )}
+                  />
+                  <input name="intent" type="hidden" value="clear-sign-off" />
+                  <input
+                    name="catalogEntryId"
+                    type="hidden"
+                    value={
+                      signoffView.acknowledgment.attestation.evidence
+                        .verification.resolution.blocker.progress.checklist
+                        .assignment.review.visibility.catalogEntry.entry.id
+                    }
+                  />
+                  <button type="submit">Clear sign-offs</button>
+                </form>
+              </div>
+              {activeCatalogChecklistItemSignoff?.signoff.catalogEntryId ===
+              signoffView.signoff.catalogEntryId ? (
+                <div className="timeline-meta">Active sign-offs selected</div>
+              ) : null}
+            </li>
+          ))}
+        </ol>
+      )}
+    </section>
+  );
+}
+
 export function CatalogReviewAssignmentsView({
   activeCatalogReviewAssignment,
   assignedEntries,
@@ -1613,6 +1767,7 @@ export function CatalogReviewSignalsView({
 export function AuditViewCatalogsView({
   activeCatalogEntry,
   activeCatalogChecklistItemBlocker,
+  activeCatalogChecklistItemSignoff,
   activeCatalogChecklistItemAcknowledgment,
   activeCatalogChecklistItemAttestation,
   activeCatalogChecklistItemEvidence,
@@ -1620,6 +1775,7 @@ export function AuditViewCatalogsView({
   activeCatalogChecklistItemVerification,
   activeCatalogChecklistItemProgress,
   assignedEntries,
+  signedOffEntries,
   acknowledgedEntries,
   attestedEntries,
   blockedEntries,
@@ -1633,6 +1789,7 @@ export function AuditViewCatalogsView({
 }: Readonly<{
   activeCatalogEntry?: ApiAuditCatalogVisibilityView;
   activeCatalogChecklistItemBlocker?: ApiAuditCatalogChecklistItemBlockerView;
+  activeCatalogChecklistItemSignoff?: ApiAuditCatalogChecklistItemSignoffView;
   activeCatalogChecklistItemAcknowledgment?: ApiAuditCatalogChecklistItemAcknowledgmentView;
   activeCatalogChecklistItemAttestation?: ApiAuditCatalogChecklistItemAttestationView;
   activeCatalogChecklistItemEvidence?: ApiAuditCatalogChecklistItemEvidenceView;
@@ -1640,6 +1797,7 @@ export function AuditViewCatalogsView({
   activeCatalogChecklistItemVerification?: ApiAuditCatalogChecklistItemVerificationView;
   activeCatalogChecklistItemProgress?: ApiAuditCatalogChecklistItemProgressView;
   assignedEntries: ApiAuditCatalogReviewAssignmentCollection;
+  signedOffEntries: ApiAuditCatalogChecklistItemSignoffCollection;
   acknowledgedEntries: ApiAuditCatalogChecklistItemAcknowledgmentCollection;
   attestedEntries: ApiAuditCatalogChecklistItemAttestationCollection;
   blockedEntries: ApiAuditCatalogChecklistItemBlockerCollection;
@@ -1739,6 +1897,17 @@ export function AuditViewCatalogsView({
         ] as const,
     ),
   );
+  const signoffsByCatalogEntryId = new Map(
+    signedOffEntries.items.map(
+      (item) =>
+        [
+          item.acknowledgment.attestation.evidence.verification.resolution
+            .blocker.progress.checklist.assignment.review.visibility
+            .catalogEntry.entry.id,
+          item,
+        ] as const,
+    ),
+  );
 
   return (
     <section className="card">
@@ -1825,6 +1994,15 @@ export function AuditViewCatalogsView({
                     : acknowledgmentsByCatalogEntryId.get(
                         catalogEntry.catalogEntry.entry.id,
                       );
+                const signoff =
+                  activeCatalogChecklistItemSignoff?.acknowledgment.attestation
+                    .evidence.verification.resolution.blocker.progress.checklist
+                    .assignment.review.visibility.catalogEntry.entry.id ===
+                  catalogEntry.catalogEntry.entry.id
+                    ? activeCatalogChecklistItemSignoff
+                    : signoffsByCatalogEntryId.get(
+                        catalogEntry.catalogEntry.entry.id,
+                      );
                 const reviewSignal = reviewSignalsByCatalogEntryId.get(
                   catalogEntry.catalogEntry.entry.id,
                 );
@@ -1867,6 +2045,14 @@ export function AuditViewCatalogsView({
                                 attestation.attestation.items,
                               )}`
                             : ""}
+                          {acknowledgment
+                            ? ` · ${formatAcknowledgmentSummary(
+                                acknowledgment.acknowledgment.items,
+                              )}`
+                            : ""}
+                          {signoff
+                            ? ` · ${formatSignoffSummary(signoff.signoff.items)}`
+                            : ""}
                         </div>
                       </div>
                       <span>
@@ -2581,6 +2767,57 @@ export function AuditViewCatalogsView({
                         </div>
                       </form>
                     ) : null}
+                    {acknowledgment ? (
+                      <form
+                        action="/runs/catalog"
+                        className="decision-form"
+                        method="post"
+                      >
+                        <input
+                          name="returnTo"
+                          type="hidden"
+                          value={buildCatalogEntryHref(
+                            catalogEntry.catalogEntry.entry.id,
+                          )}
+                        />
+                        <input name="intent" type="hidden" value="sign-off" />
+                        <input
+                          name="catalogEntryId"
+                          type="hidden"
+                          value={catalogEntry.catalogEntry.entry.id}
+                        />
+                        <div className="data-grid">
+                          <label>
+                            <span>Checklist item sign-offs</span>
+                            <textarea
+                              className="note-input"
+                              defaultValue={formatChecklistItemSignoffLines(
+                                acknowledgment.acknowledgment.items,
+                                signoff?.signoff.items,
+                              )}
+                              name="signoffItems"
+                              placeholder="signed-off: Validate queued follow-up"
+                              rows={4}
+                            />
+                          </label>
+                          <label>
+                            <span>Sign-off note</span>
+                            <input
+                              defaultValue={signoff?.signoff.signoffNote ?? ""}
+                              name="signoffNote"
+                              placeholder="Optional thin sign-off note"
+                              type="text"
+                            />
+                          </label>
+                        </div>
+                        <div className="row spread">
+                          <div />
+                          <button type="submit">
+                            {signoff ? "Update sign-offs" : "Save sign-offs"}
+                          </button>
+                        </div>
+                      </form>
+                    ) : null}
                     <div className="row spread">
                       <a
                         className="link-button"
@@ -4321,6 +4558,16 @@ function formatAcknowledgmentSummary(
   return `${acknowledgedCount}/${items.length} acknowledged`;
 }
 
+function formatSignoffSummary(
+  items: readonly ApiAuditCatalogChecklistItemSignoffItem[],
+): string {
+  const signedOffCount = items.filter(
+    (item) => item.state === "signed-off",
+  ).length;
+
+  return `${signedOffCount}/${items.length} signed off`;
+}
+
 function formatChecklistItemProgressLines(
   checklistItems: readonly string[],
   progressItems:
@@ -4440,6 +4687,23 @@ function formatChecklistItemAcknowledgmentLines(
     .join("\n");
 }
 
+function formatChecklistItemSignoffLines(
+  acknowledgmentItems:
+    | readonly ApiAuditCatalogChecklistItemAcknowledgmentItem[]
+    | undefined,
+  signoffItems: readonly ApiAuditCatalogChecklistItemSignoffItem[] | undefined,
+): string {
+  const signoffByItem = new Map(
+    (signoffItems ?? []).map((item) => [item.item, item.state] as const),
+  );
+
+  return (acknowledgmentItems ?? [])
+    .map(
+      (item) => `${signoffByItem.get(item.item) ?? "unsigned"}: ${item.item}`,
+    )
+    .join("\n");
+}
+
 function buildSavedAuditViewHref(savedViewId: string): string {
   return `/runs?savedViewId=${encodeURIComponent(savedViewId)}`;
 }
diff --git a/apps/web/src/lib/runroot-api.ts b/apps/web/src/lib/runroot-api.ts
index cb01fa0..db8594a 100644
--- a/apps/web/src/lib/runroot-api.ts
+++ b/apps/web/src/lib/runroot-api.ts
@@ -584,6 +584,32 @@ export interface ApiAuditCatalogChecklistItemAcknowledgmentCollection {
   readonly totalCount: number;
 }
 
+export interface ApiAuditCatalogChecklistItemSignoffItem {
+  readonly item: string;
+  readonly state: "signed-off" | "unsigned";
+}
+
+export interface ApiAuditCatalogChecklistItemSignoff {
+  readonly catalogEntryId: string;
+  readonly createdAt: string;
+  readonly items: readonly ApiAuditCatalogChecklistItemSignoffItem[];
+  readonly kind: "catalog-checklist-item-signoff";
+  readonly operatorId: string;
+  readonly scopeId: string;
+  readonly signoffNote?: string;
+  readonly updatedAt: string;
+}
+
+export interface ApiAuditCatalogChecklistItemSignoffView {
+  readonly acknowledgment: ApiAuditCatalogChecklistItemAcknowledgmentView;
+  readonly signoff: ApiAuditCatalogChecklistItemSignoff;
+}
+
+export interface ApiAuditCatalogChecklistItemSignoffCollection {
+  readonly items: readonly ApiAuditCatalogChecklistItemSignoffView[];
+  readonly totalCount: number;
+}
+
 export interface ApiAuditCatalogChecklistItemAttestationItem {
   readonly item: string;
   readonly state: "attested" | "unattested";
@@ -656,6 +682,11 @@ export interface UpdateApiAuditCatalogChecklistItemAcknowledgmentInput {
   readonly items: readonly ApiAuditCatalogChecklistItemAcknowledgmentItem[];
 }
 
+export interface UpdateApiAuditCatalogChecklistItemSignoffInput {
+  readonly items: readonly ApiAuditCatalogChecklistItemSignoffItem[];
+  readonly signoffNote?: string;
+}
+
 export interface UpdateApiAuditCatalogReviewAssignmentInput {
   readonly assigneeId: string;
   readonly handoffNote?: string;
@@ -704,6 +735,9 @@ export interface RunrootApiClient {
   clearAuditCatalogChecklistItemEvidence(
     catalogEntryId: string,
   ): Promise<ApiAuditCatalogChecklistItemEvidenceView>;
+  clearAuditCatalogChecklistItemSignoff(
+    catalogEntryId: string,
+  ): Promise<ApiAuditCatalogChecklistItemSignoffView>;
   clearAuditCatalogChecklistItemAcknowledgment(
     catalogEntryId: string,
   ): Promise<ApiAuditCatalogChecklistItemAcknowledgmentView>;
@@ -737,6 +771,9 @@ export interface RunrootApiClient {
   getAuditCatalogChecklistItemEvidence(
     catalogEntryId: string,
   ): Promise<ApiAuditCatalogChecklistItemEvidenceView>;
+  getAuditCatalogChecklistItemSignoff(
+    catalogEntryId: string,
+  ): Promise<ApiAuditCatalogChecklistItemSignoffView>;
   getAuditCatalogChecklistItemAcknowledgment(
     catalogEntryId: string,
   ): Promise<ApiAuditCatalogChecklistItemAcknowledgmentView>;
@@ -775,6 +812,7 @@ export interface RunrootApiClient {
   getSavedAuditView(savedViewId: string): Promise<ApiAuditSavedView>;
   listAssignedAuditCatalogEntries(): Promise<ApiAuditCatalogReviewAssignmentCollection>;
   listBlockedAuditCatalogEntries(): Promise<ApiAuditCatalogChecklistItemBlockerCollection>;
+  listSignedOffAuditCatalogEntries(): Promise<ApiAuditCatalogChecklistItemSignoffCollection>;
   listAcknowledgedAuditCatalogEntries(): Promise<ApiAuditCatalogChecklistItemAcknowledgmentCollection>;
   listEvidencedAuditCatalogEntries(): Promise<ApiAuditCatalogChecklistItemEvidenceCollection>;
   listAttestedAuditCatalogEntries(): Promise<ApiAuditCatalogChecklistItemAttestationCollection>;
@@ -811,6 +849,10 @@ export interface RunrootApiClient {
     catalogEntryId: string,
     input: UpdateApiAuditCatalogChecklistItemEvidenceInput,
   ): Promise<ApiAuditCatalogChecklistItemEvidenceView>;
+  setAuditCatalogChecklistItemSignoff(
+    catalogEntryId: string,
+    input: UpdateApiAuditCatalogChecklistItemSignoffInput,
+  ): Promise<ApiAuditCatalogChecklistItemSignoffView>;
   setAuditCatalogChecklistItemAcknowledgment(
     catalogEntryId: string,
     input: UpdateApiAuditCatalogChecklistItemAcknowledgmentInput,
@@ -1055,6 +1097,18 @@ export function createRunrootApiClient(
       return payload.evidence;
     },
 
+    async clearAuditCatalogChecklistItemSignoff(catalogEntryId) {
+      const payload = await requestJson<{
+        signoff: ApiAuditCatalogChecklistItemSignoffView;
+      }>(
+        `/audit/catalog/${catalogEntryId}/sign-off/clear`,
+        { method: "POST" },
+        "web.api.clearAuditCatalogChecklistItemSignoff",
+      );
+
+      return payload.signoff;
+    },
+
     async clearAuditCatalogChecklistItemAcknowledgment(catalogEntryId) {
       const payload = await requestJson<{
         acknowledgment: ApiAuditCatalogChecklistItemAcknowledgmentView;
@@ -1187,6 +1241,18 @@ export function createRunrootApiClient(
       return payload.evidence;
     },
 
+    async getAuditCatalogChecklistItemSignoff(catalogEntryId) {
+      const payload = await requestJson<{
+        signoff: ApiAuditCatalogChecklistItemSignoffView;
+      }>(
+        `/audit/catalog/${catalogEntryId}/sign-off`,
+        { method: "GET" },
+        "web.api.getAuditCatalogChecklistItemSignoff",
+      );
+
+      return payload.signoff;
+    },
+
     async getAuditCatalogChecklistItemAcknowledgment(catalogEntryId) {
       const payload = await requestJson<{
         acknowledgment: ApiAuditCatalogChecklistItemAcknowledgmentView;
@@ -1399,6 +1465,18 @@ export function createRunrootApiClient(
       return payload.blocked;
     },
 
+    async listSignedOffAuditCatalogEntries() {
+      const payload = await requestJson<{
+        signedOff: ApiAuditCatalogChecklistItemSignoffCollection;
+      }>(
+        "/audit/catalog/signed-off",
+        { method: "GET" },
+        "web.api.listSignedOffAuditCatalogEntries",
+      );
+
+      return payload.signedOff;
+    },
+
     async listResolvedAuditCatalogEntries() {
       const payload = await requestJson<{
         resolved: ApiAuditCatalogChecklistItemResolutionCollection;
@@ -1639,6 +1717,24 @@ export function createRunrootApiClient(
       return payload.evidence;
     },
 
+    async setAuditCatalogChecklistItemSignoff(catalogEntryId, input) {
+      const payload = await requestJson<{
+        signoff: ApiAuditCatalogChecklistItemSignoffView;
+      }>(
+        `/audit/catalog/${catalogEntryId}/sign-off`,
+        {
+          body: JSON.stringify(input),
+          headers: {
+            "content-type": "application/json",
+          },
+          method: "POST",
+        },
+        "web.api.setAuditCatalogChecklistItemSignoff",
+      );
+
+      return payload.signoff;
+    },
+
     async setAuditCatalogChecklistItemAttestation(catalogEntryId, input) {
       const payload = await requestJson<{
         attestation: ApiAuditCatalogChecklistItemAttestationView;
diff --git a/docs/architecture/adr-0028-cross-run-audit-catalog-checklist-item-sign-offs-and-sign-off-notes.md b/docs/architecture/adr-0028-cross-run-audit-catalog-checklist-item-sign-offs-and-sign-off-notes.md
new file mode 100644
index 0000000..242c1e4
--- /dev/null
+++ b/docs/architecture/adr-0028-cross-run-audit-catalog-checklist-item-sign-offs-and-sign-off-notes.md
@@ -0,0 +1,112 @@
+# ADR-0028: Cross-Run Audit Catalog Checklist Item Sign-Offs and Sign-Off Notes
+
+Date: 2026-04-04
+
+## Status
+
+Accepted on branch for Phase 28 implementation.
+
+## Context
+
+Phase 27 added a thin checklist-item-acknowledgment layer over attested
+evidenced verified resolved blocked progressed assigned reviewed audit catalog
+entries. Operators could record that the current attestation and supporting
+evidence set had been acknowledged, but there was still no package-owned way
+to capture that a downstream operator had signed off the current
+acknowledgment, attestation, and evidence set without expanding into approval
+gating, workflow orchestration, artifact-vault behavior, attachment-upload
+products, provider-payload persistence, copied artifact persistence, or a
+broader collaboration system.
+
+The next repository-owned gap is still narrower than threaded collaboration,
+broader checklist orchestration, broader review workflow engines,
+fine-grained RBAC, multi-tenant access, dashboards, search, analytics,
+approval products, or attachment-upload products. Runroot needs a stable
+checklist-item-signoff layer that remains derived over the existing
+checklist-item-acknowledgment, checklist-item-attestation,
+checklist-item-evidence, checklist-item-verification,
+checklist-item-resolution, checklist-item-blocker,
+checklist-item-progress, assignment-checklist, review-assignment,
+review-signal, visibility, catalog, and saved-view seams.
+
+## Decision
+
+Runroot adds a shared audit-catalog checklist-item-signoff contract
+with the following properties:
+
+- checklist item sign-offs remain additive operator metadata
+- checklist item sign-offs reference existing catalog entries,
+  checklist-item-acknowledgments, checklist-item-attestations,
+  checklist-item-evidence, checklist-item-verifications,
+  checklist-item-resolutions, checklist-item-blockers,
+  checklist-item-progress, assignment checklists, review assignments, and
+  review signals
+- checklist item sign-offs store only stable per-item sign-off state, a thin
+  optional sign-off note, minimal actor and scope references, and existing
+  catalog refs
+- checklist item sign-offs do not snapshot audit facts, provider
+  payloads, copied artifacts, or workflow state
+- checklist item sign-offs do not change replay or approval source of
+  truth
+- applying a signed-off preset reuses the existing catalog-apply path
+
+The shared sign-off seam is exposed through:
+
+- replay query helpers in `@runroot/replay`
+- persistence adapters in `@runroot/persistence`
+- operator methods in `@runroot/sdk`
+- thin HTTP routes in `apps/api`
+- thin command routing in `@runroot/cli`
+- minimal runs-page presentation in `apps/web`
+
+Sign-Off visibility stays minimal:
+
+- list and inspect are scoped to operators already involved in the
+  acknowledgment, attestation, evidence, verification, resolution, blocker,
+  progress, and assignment handoff path
+- sign-off entries can only reference checklist items that already exist in
+  the shared checklist-item-acknowledgment layer
+- sign-off state stays as a thin per-item enum
+- sign-off notes stay as a single thin string
+- no threaded comments, checklist workflow engine, approval-gating product,
+  permission framework, organization directory, multi-tenant surface,
+  attachment-upload product, or artifact vault is added
+
+## Consequences
+
+### Positive
+
+- attested evidenced verified resolved blocked progressed assigned reviewed
+  presets can carry thin per-item sign-off state and a single sign-off note
+  through shared package-owned seams
+- inline and queued runs reuse the same checklist-item-signoff contract
+- operator surfaces stay thin and reuse the existing catalog apply behavior
+- replay and approval semantics remain unchanged
+
+### Negative
+
+- checklist item sign-offs are still a derived layer that depends on
+  checklist-item acknowledgment, checklist-item attestation,
+  checklist-item evidence, checklist-item verifications,
+  checklist-item resolutions, checklist-item blockers,
+  checklist-item progress, assignment checklists, assignments, review
+  signals, visibility, and catalog integrity
+- sign-offs intentionally stay shallow and do not solve approval
+  products, workflow gating, broader checklist orchestration, threaded
+  collaboration, payload persistence, binary artifact persistence, RBAC, or
+  multi-tenant requirements
+
+## Non-Goals
+
+This ADR does not introduce:
+
+- threaded comments
+- broader review workflow engines
+- broader checklist orchestration
+- sign-off-driven approval gating
+- attachment-upload or artifact-vault products
+- fine-grained RBAC
+- multi-tenant access control
+- dashboard, search, or analytics products
+- broader collaboration beyond thin operator-facing sign-off metadata
+- provider payload, copied artifact, or full snapshot persistence
diff --git a/docs/guides/audit-catalog-checklist-item-sign-offs.md b/docs/guides/audit-catalog-checklist-item-sign-offs.md
new file mode 100644
index 0000000..0c497bb
--- /dev/null
+++ b/docs/guides/audit-catalog-checklist-item-sign-offs.md
@@ -0,0 +1,133 @@
+# Audit Catalog Checklist Item Sign-Offs
+
+Phase 28 adds a thin shared checklist-item-signoff layer over acknowledged
+attested evidenced verified resolved blocked progressed assigned reviewed audit
+catalog entries that already carry checklist-item-acknowledgment metadata.
+
+## What Checklist Item Sign-Offs Record
+
+The shared contract stores:
+
+- a reference to an existing acknowledged attested evidenced verified resolved
+  blocked progressed assigned reviewed catalog entry
+- per-item sign-off state for checklist items that already exist in the shared
+  checklist-item-acknowledgment layer
+- minimal operator and scope references used by the current operator seam
+- an optional thin sign-off note
+
+The contract does not store:
+
+- provider-specific payloads
+- copied artifacts
+- workflow-state snapshots
+- replay or approval state
+- threaded comments, broader review workflow engines, or broader checklist
+  orchestration
+- fine-grained RBAC or multi-tenant access rules
+- surface-specific route formats
+- approval-gating product state
+- attachment-upload or artifact-vault product state
+
+Checklist item sign-offs remain derived operator state. They do not replace
+replay, approval, saved views, catalog entries, visibility, review signals,
+review assignments, assignment checklists, checklist-item progress,
+checklist-item blockers, checklist-item resolutions, checklist-item
+verifications, checklist-item evidence, checklist-item attestations, or
+checklist-item acknowledgments.
+
+## Sign-Off, List-Signed-Off, Inspect-Sign-Off, Clear-Sign-Off, And Apply
+
+The minimum sign-off path is available through the existing seams:
+
+- SDK:
+  - `signOffCatalogEntry(id, ...)`
+  - `listSignedOffCatalogEntries()`
+  - `getCatalogChecklistItemSignoff(id)`
+  - `clearCatalogChecklistItemSignoff(id)`
+  - `applyCatalogEntry(id)`
+- API:
+  - `POST /audit/catalog/:catalogEntryId/sign-off`
+  - `GET /audit/catalog/signed-off`
+  - `GET /audit/catalog/:catalogEntryId/sign-off`
+  - `POST /audit/catalog/:catalogEntryId/sign-off/clear`
+  - `GET /audit/catalog/:catalogEntryId/apply`
+- CLI:
+  - `audit catalog sign-off`
+  - `audit catalog signed-off`
+  - `audit catalog inspect-sign-off`
+  - `audit catalog clear-sign-off`
+  - `audit catalog apply`
+- Web:
+  - the runs page presents a thin checklist-item-signoff panel and a minimal
+    sign-off-note form over the existing catalog, visibility, review-signal,
+    review-assignment, assignment-checklist, checklist-item-progress,
+    checklist-item-blocker, checklist-item-resolution,
+    checklist-item-verification, checklist-item-evidence,
+    checklist-item-attestation, and checklist-item-acknowledgment surfaces
+
+## What Applying A Signed-Off Preset Does
+
+Applying a signed-off preset does not replay a run, reconstruct workflow
+state, or change approval semantics.
+
+It only:
+
+- resolves the visible catalog entry for the current operator identity
+- resolves additive review, assignment, checklist, progress, blocker,
+  resolution, verification, evidence, attestation, acknowledgment, and
+  sign-off metadata for that entry
+- resolves the referenced saved view and constrained navigation metadata
+- reuses the existing catalog-apply and audit-navigation seams
+- returns the current navigation state for that signed-off acknowledged preset
+
+Replay and approval semantics still come only from persisted runtime and
+approval events.
+
+## Local Development
+
+Set a minimal operator identity for the current process:
+
+```bash
+$env:RUNROOT_OPERATOR_ID="ops_oncall"
+$env:RUNROOT_OPERATOR_SCOPE="ops"
+```
+
+Create and record sign-offs on an acknowledged attested evidenced verified
+resolved blocked progressed assigned reviewed shared preset:
+
+```bash
+pnpm dev:queued
+pnpm --filter @runroot/cli dev audit saved-views save --name "queued worker" --execution-mode queued --worker-id worker_1
+pnpm --filter @runroot/cli dev audit catalog publish saved_view_1 --name "Queued preset"
+pnpm --filter @runroot/cli dev audit catalog share catalog_entry_1
+pnpm --filter @runroot/cli dev audit catalog review catalog_entry_1 --state recommended --note "Ready for sign-off"
+pnpm --filter @runroot/cli dev audit catalog assign catalog_entry_1 --assignee ops_backup --handoff-note "Take the overnight follow-up"
+pnpm --filter @runroot/cli dev audit catalog checklist catalog_entry_1 --status pending --items-json "[\"Validate worker state\",\"Confirm saved drilldown\"]"
+pnpm --filter @runroot/cli dev audit catalog progress catalog_entry_1 --items-json "[{\"item\":\"Validate worker state\",\"state\":\"completed\"},{\"item\":\"Confirm saved drilldown\",\"state\":\"pending\"}]"
+pnpm --filter @runroot/cli dev audit catalog block catalog_entry_1 --items-json "[{\"item\":\"Validate worker state\",\"state\":\"cleared\"},{\"item\":\"Confirm saved drilldown\",\"state\":\"blocked\"}]" --blocker-note "Waiting for overnight handoff"
+pnpm --filter @runroot/cli dev audit catalog resolve catalog_entry_1 --items-json "[{\"item\":\"Validate worker state\",\"state\":\"resolved\"},{\"item\":\"Confirm saved drilldown\",\"state\":\"unresolved\"}]" --resolution-note "Backup confirmed the closeout"
+pnpm --filter @runroot/cli dev audit catalog verify catalog_entry_1 --items-json "[{\"item\":\"Validate worker state\",\"state\":\"verified\"},{\"item\":\"Confirm saved drilldown\",\"state\":\"unverified\"}]" --verification-note "Owner verified the closeout"
+pnpm --filter @runroot/cli dev audit catalog record-evidence catalog_entry_1 --items-json "[{\"item\":\"Validate worker state\",\"references\":[\"run://queued-worker/step/7\",\"note://backup-closeout\"]},{\"item\":\"Confirm saved drilldown\",\"references\":[\"doc://saved-drilldown\"]}]" --evidence-note "Thin evidence references only"
+pnpm --filter @runroot/cli dev audit catalog attest catalog_entry_1 --items-json "[{\"item\":\"Validate worker state\",\"state\":\"attested\"},{\"item\":\"Confirm saved drilldown\",\"state\":\"unattested\"}]" --attestation-note "Owner attested the stable evidence references"
+pnpm --filter @runroot/cli dev audit catalog acknowledge catalog_entry_1 --items-json "[{\"item\":\"Validate worker state\",\"state\":\"acknowledged\"},{\"item\":\"Confirm saved drilldown\",\"state\":\"unacknowledged\"}]" --acknowledgment-note "Backup acknowledged the attested evidence set"
+pnpm --filter @runroot/cli dev audit catalog sign-off catalog_entry_1 --items-json "[{\"item\":\"Validate worker state\",\"state\":\"signed-off\"},{\"item\":\"Confirm saved drilldown\",\"state\":\"unsigned\"}]" --signoff-note "Backup signed off the acknowledged evidence set"
+pnpm --filter @runroot/cli dev audit catalog signed-off
+pnpm --filter @runroot/cli dev audit catalog apply catalog_entry_1
+pnpm --filter @runroot/cli dev audit catalog clear-sign-off catalog_entry_1
+```
+
+Both inline-originated and queued-originated presets reuse the same
+checklist-item-signoff contract through the configured persistence adapter.
+
+## What Stays Deferred
+
+Still out of scope after Phase 28:
+
+- productized dashboards, discovery products, or broad analytics UX
+- open-ended search products
+- fine-grained RBAC, org or team management, and multi-tenant access models
+- threaded comments, broader checklist orchestration, broader review
+  workflows, or broader multi-user curation
+- full observability backend integrations
+- provider payload persistence, copied artifact persistence, approval-gating
+  products, attachment-upload, or artifact-vault products
diff --git a/docs/roadmap.md b/docs/roadmap.md
index 42394db..a543ce8 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -449,4 +449,4 @@ Status: completed
   broader multi-user curation, approval products, workflow gating, or broad
   observability and analytics platform work
 
-Status: scope frozen
+Status: completed
diff --git a/packages/cli/src/index.integration.test.ts b/packages/cli/src/index.integration.test.ts
index a221364..60e3bcc 100644
--- a/packages/cli/src/index.integration.test.ts
+++ b/packages/cli/src/index.integration.test.ts
@@ -4989,7 +4989,7 @@ describe("@runroot/cli integration", () => {
     expect(attestedAfterClearPayload.attested.totalCount).toBe(0);
   });
 
-  it("records acknowledgments, lists-acknowledged, inspects, clears, and reapplies attested catalog entries through the CLI", async () => {
+  it("records acknowledgments and sign-offs, lists, inspects, clears, and reapplies attested catalog entries through the CLI", async () => {
     const workspaceRoot = await mkdtemp(
       join(tmpdir(), "runroot-cli-checklist-acknowledgment-"),
     );
@@ -5018,10 +5018,15 @@ describe("@runroot/cli integration", () => {
     const evidenceIo = createIo();
     const attestationIo = createIo();
     const acknowledgmentIo = createIo();
+    const signoffIo = createIo();
     const acknowledgedPeerIo = createIo();
+    const signedOffPeerIo = createIo();
     const inspectAcknowledgmentIo = createIo();
+    const inspectSignoffIo = createIo();
     const applyIo = createIo();
+    const clearSignoffIo = createIo();
     const clearAcknowledgmentIo = createIo();
+    const signedOffAfterClearIo = createIo();
     const acknowledgedAfterClearIo = createIo();
 
     await runCli(
@@ -5421,6 +5426,37 @@ describe("@runroot/cli integration", () => {
         io: acknowledgmentIo.io,
       },
     );
+    const signoffExitCode = await runCli(
+      [
+        "audit",
+        "catalog",
+        "sign-off",
+        publishedPayload.catalogEntry.entry.id,
+        "--items-json",
+        JSON.stringify([
+          {
+            item: "Validate queued follow-up",
+            state: "signed-off",
+          },
+          {
+            item: "Close backup handoff",
+            state: "unsigned",
+          },
+        ]),
+        "--signoff-note",
+        "Backup signed off the acknowledged follow-up",
+      ],
+      {
+        cwd: workspaceRoot,
+        env: {
+          RUNROOT_OPERATOR_ID: "ops_oncall",
+          RUNROOT_OPERATOR_SCOPE: "ops",
+          RUNROOT_PERSISTENCE_DRIVER: "sqlite",
+          RUNROOT_SQLITE_PATH: sqlitePath,
+        },
+        io: signoffIo.io,
+      },
+    );
     const acknowledgedPeerExitCode = await runCli(
       ["audit", "catalog", "acknowledged"],
       {
@@ -5434,6 +5470,19 @@ describe("@runroot/cli integration", () => {
         io: acknowledgedPeerIo.io,
       },
     );
+    const signedOffPeerExitCode = await runCli(
+      ["audit", "catalog", "signed-off"],
+      {
+        cwd: workspaceRoot,
+        env: {
+          RUNROOT_OPERATOR_ID: "ops_backup",
+          RUNROOT_OPERATOR_SCOPE: "ops",
+          RUNROOT_PERSISTENCE_DRIVER: "sqlite",
+          RUNROOT_SQLITE_PATH: sqlitePath,
+        },
+        io: signedOffPeerIo.io,
+      },
+    );
     const inspectAcknowledgmentExitCode = await runCli(
       [
         "audit",
@@ -5452,6 +5501,24 @@ describe("@runroot/cli integration", () => {
         io: inspectAcknowledgmentIo.io,
       },
     );
+    const inspectSignoffExitCode = await runCli(
+      [
+        "audit",
+        "catalog",
+        "inspect-sign-off",
+        publishedPayload.catalogEntry.entry.id,
+      ],
+      {
+        cwd: workspaceRoot,
+        env: {
+          RUNROOT_OPERATOR_ID: "ops_oncall",
+          RUNROOT_OPERATOR_SCOPE: "ops",
+          RUNROOT_PERSISTENCE_DRIVER: "sqlite",
+          RUNROOT_SQLITE_PATH: sqlitePath,
+        },
+        io: inspectSignoffIo.io,
+      },
+    );
     const applyExitCode = await runCli(
       ["audit", "catalog", "apply", publishedPayload.catalogEntry.entry.id],
       {
@@ -5465,6 +5532,24 @@ describe("@runroot/cli integration", () => {
         io: applyIo.io,
       },
     );
+    const clearSignoffExitCode = await runCli(
+      [
+        "audit",
+        "catalog",
+        "clear-sign-off",
+        publishedPayload.catalogEntry.entry.id,
+      ],
+      {
+        cwd: workspaceRoot,
+        env: {
+          RUNROOT_OPERATOR_ID: "ops_oncall",
+          RUNROOT_OPERATOR_SCOPE: "ops",
+          RUNROOT_PERSISTENCE_DRIVER: "sqlite",
+          RUNROOT_SQLITE_PATH: sqlitePath,
+        },
+        io: clearSignoffIo.io,
+      },
+    );
     const clearAcknowledgmentExitCode = await runCli(
       [
         "audit",
@@ -5483,6 +5568,19 @@ describe("@runroot/cli integration", () => {
         io: clearAcknowledgmentIo.io,
       },
     );
+    const signedOffAfterClearExitCode = await runCli(
+      ["audit", "catalog", "signed-off"],
+      {
+        cwd: workspaceRoot,
+        env: {
+          RUNROOT_OPERATOR_ID: "ops_backup",
+          RUNROOT_OPERATOR_SCOPE: "ops",
+          RUNROOT_PERSISTENCE_DRIVER: "sqlite",
+          RUNROOT_SQLITE_PATH: sqlitePath,
+        },
+        io: signedOffAfterClearIo.io,
+      },
+    );
     const acknowledgedAfterClearExitCode = await runCli(
       ["audit", "catalog", "acknowledged"],
       {
@@ -5524,6 +5622,27 @@ describe("@runroot/cli integration", () => {
         };
       };
     };
+    const signoffPayload = JSON.parse(signoffIo.stdout.join("")) as {
+      signoff: {
+        acknowledgment: {
+          acknowledgment: {
+            acknowledgmentNote?: string;
+          };
+          attestation: {
+            attestation: {
+              attestationNote?: string;
+            };
+          };
+        };
+        signoff: {
+          signoffNote?: string;
+          items: Array<{
+            item: string;
+            state: "signed-off" | "unsigned";
+          }>;
+        };
+      };
+    };
     const acknowledgedPeerPayload = JSON.parse(
       acknowledgedPeerIo.stdout.join(""),
     ) as {
@@ -5561,6 +5680,45 @@ describe("@runroot/cli integration", () => {
         totalCount: number;
       };
     };
+    const signedOffPeerPayload = JSON.parse(
+      signedOffPeerIo.stdout.join(""),
+    ) as {
+      signedOff: {
+        items: Array<{
+          acknowledgment: {
+            attestation: {
+              evidence: {
+                verification: {
+                  resolution: {
+                    blocker: {
+                      progress: {
+                        checklist: {
+                          assignment: {
+                            review: {
+                              visibility: {
+                                catalogEntry: {
+                                  entry: {
+                                    id: string;
+                                  };
+                                };
+                              };
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+          signoff: {
+            signoffNote?: string;
+          };
+        }>;
+        totalCount: number;
+      };
+    };
     const inspectAcknowledgmentPayload = JSON.parse(
       inspectAcknowledgmentIo.stdout.join(""),
     ) as {
@@ -5574,6 +5732,19 @@ describe("@runroot/cli integration", () => {
         };
       };
     };
+    const inspectSignoffPayload = JSON.parse(
+      inspectSignoffIo.stdout.join(""),
+    ) as {
+      signoff: {
+        signoff: {
+          signoffNote?: string;
+          items: Array<{
+            item: string;
+            state: "signed-off" | "unsigned";
+          }>;
+        };
+      };
+    };
     const applyPayload = JSON.parse(applyIo.stdout.join("")) as {
       application: {
         application: {
@@ -5591,6 +5762,13 @@ describe("@runroot/cli integration", () => {
         };
       };
     };
+    const clearSignoffPayload = JSON.parse(clearSignoffIo.stdout.join("")) as {
+      signoff: {
+        signoff: {
+          signoffNote?: string;
+        };
+      };
+    };
     const clearAcknowledgmentPayload = JSON.parse(
       clearAcknowledgmentIo.stdout.join(""),
     ) as {
@@ -5600,6 +5778,13 @@ describe("@runroot/cli integration", () => {
         };
       };
     };
+    const signedOffAfterClearPayload = JSON.parse(
+      signedOffAfterClearIo.stdout.join(""),
+    ) as {
+      signedOff: {
+        totalCount: number;
+      };
+    };
     const acknowledgedAfterClearPayload = JSON.parse(
       acknowledgedAfterClearIo.stdout.join(""),
     ) as {
@@ -5620,10 +5805,15 @@ describe("@runroot/cli integration", () => {
     expect(evidenceExitCode).toBe(0);
     expect(attestationExitCode).toBe(0);
     expect(acknowledgmentExitCode).toBe(0);
+    expect(signoffExitCode).toBe(0);
     expect(acknowledgedPeerExitCode).toBe(0);
+    expect(signedOffPeerExitCode).toBe(0);
     expect(inspectAcknowledgmentExitCode).toBe(0);
+    expect(inspectSignoffExitCode).toBe(0);
     expect(applyExitCode).toBe(0);
+    expect(clearSignoffExitCode).toBe(0);
     expect(clearAcknowledgmentExitCode).toBe(0);
+    expect(signedOffAfterClearExitCode).toBe(0);
     expect(acknowledgedAfterClearExitCode).toBe(0);
     expect(
       acknowledgmentPayload.acknowledgment.attestation.evidence.verification
@@ -5650,16 +5840,58 @@ describe("@runroot/cli integration", () => {
         state: "unacknowledged",
       },
     ]);
+    expect(
+      signoffPayload.signoff.acknowledgment.acknowledgment.acknowledgmentNote,
+    ).toBe("Backup acknowledged the attested follow-up");
+    expect(
+      signoffPayload.signoff.acknowledgment.attestation.attestation
+        .attestationNote,
+    ).toBe("Backup attested the stable follow-up evidence");
+    expect(signoffPayload.signoff.signoff.signoffNote).toBe(
+      "Backup signed off the acknowledged follow-up",
+    );
+    expect(signoffPayload.signoff.signoff.items).toEqual([
+      {
+        item: "Validate queued follow-up",
+        state: "signed-off",
+      },
+      {
+        item: "Close backup handoff",
+        state: "unsigned",
+      },
+    ]);
     expect(acknowledgedPeerPayload.acknowledged.totalCount).toBe(1);
     expect(
       acknowledgedPeerPayload.acknowledged.items[0]?.attestation.evidence
         .verification.resolution.blocker.progress.checklist.assignment.review
         .visibility.catalogEntry.entry.id,
     ).toBe(publishedPayload.catalogEntry.entry.id);
+    expect(signedOffPeerPayload.signedOff.totalCount).toBe(1);
+    expect(
+      signedOffPeerPayload.signedOff.items[0]?.acknowledgment.attestation
+        .evidence.verification.resolution.blocker.progress.checklist.assignment
+        .review.visibility.catalogEntry.entry.id,
+    ).toBe(publishedPayload.catalogEntry.entry.id);
+    expect(signedOffPeerPayload.signedOff.items[0]?.signoff.signoffNote).toBe(
+      "Backup signed off the acknowledged follow-up",
+    );
     expect(
       inspectAcknowledgmentPayload.acknowledgment.acknowledgment
         .acknowledgmentNote,
     ).toBe("Backup acknowledged the attested follow-up");
+    expect(inspectSignoffPayload.signoff.signoff.signoffNote).toBe(
+      "Backup signed off the acknowledged follow-up",
+    );
+    expect(inspectSignoffPayload.signoff.signoff.items).toEqual([
+      {
+        item: "Validate queued follow-up",
+        state: "signed-off",
+      },
+      {
+        item: "Close backup handoff",
+        state: "unsigned",
+      },
+    ]);
     expect(applyPayload.application.application.savedView.id).toBe(
       savedViewPayload.savedView.id,
     );
@@ -5671,6 +5903,10 @@ describe("@runroot/cli integration", () => {
       clearAcknowledgmentPayload.acknowledgment.acknowledgment
         .acknowledgmentNote,
     ).toBe("Backup acknowledged the attested follow-up");
+    expect(clearSignoffPayload.signoff.signoff.signoffNote).toBe(
+      "Backup signed off the acknowledged follow-up",
+    );
+    expect(signedOffAfterClearPayload.signedOff.totalCount).toBe(0);
     expect(acknowledgedAfterClearPayload.acknowledged.totalCount).toBe(0);
   });
 });
diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts
index 19e24f6..264dd22 100644
--- a/packages/cli/src/index.ts
+++ b/packages/cli/src/index.ts
@@ -204,6 +204,19 @@ export async function runCli(
               resolveAcknowledgeAuditCatalogEntryInput(flags),
             ),
           });
+        case "sign-off":
+          if (!detail) {
+            throw new Error(
+              "audit catalog sign-off requires a catalog entry id.",
+            );
+          }
+
+          return writeJson(io.stdout.write, {
+            signoff: await service.signOffCatalogEntry(
+              detail,
+              resolveSignOffAuditCatalogEntryInput(flags),
+            ),
+          });
         case "record-evidence":
           if (!detail) {
             throw new Error(
@@ -245,6 +258,10 @@ export async function runCli(
           return writeJson(io.stdout.write, {
             acknowledged: await service.listAcknowledgedCatalogEntries(),
           });
+        case "signed-off":
+          return writeJson(io.stdout.write, {
+            signedOff: await service.listSignedOffCatalogEntries(),
+          });
         case "checklist":
           if (!detail) {
             throw new Error(
@@ -336,6 +353,16 @@ export async function runCli(
             acknowledgment:
               await service.clearCatalogChecklistItemAcknowledgment(detail),
           });
+        case "clear-sign-off":
+          if (!detail) {
+            throw new Error(
+              "audit catalog clear-sign-off requires a catalog entry id.",
+            );
+          }
+
+          return writeJson(io.stdout.write, {
+            signoff: await service.clearCatalogChecklistItemSignoff(detail),
+          });
         case "clear-assignment":
           if (!detail) {
             throw new Error(
@@ -469,6 +496,16 @@ export async function runCli(
             acknowledgment:
               await service.getCatalogChecklistItemAcknowledgment(detail),
           });
+        case "inspect-sign-off":
+          if (!detail) {
+            throw new Error(
+              "audit catalog inspect-sign-off requires a catalog entry id.",
+            );
+          }
+
+          return writeJson(io.stdout.write, {
+            signoff: await service.getCatalogChecklistItemSignoff(detail),
+          });
         case "inspect-review":
           if (!detail) {
             throw new Error(
@@ -989,6 +1026,30 @@ function resolveAcknowledgeAuditCatalogEntryInput(
   };
 }
 
+function resolveSignOffAuditCatalogEntryInput(
+  flags: ReadonlyMap<string, string | boolean>,
+): {
+  readonly items: readonly {
+    readonly item: string;
+    readonly state: "signed-off" | "unsigned";
+  }[];
+  readonly signoffNote?: string;
+} {
+  const itemsJson = getStringFlag(flags, "items-json");
+  const signoffNote = getStringFlag(flags, "signoff-note");
+
+  if (!itemsJson) {
+    throw new Error(
+      "audit catalog sign-off requires --items-json <json-array>.",
+    );
+  }
+
+  return {
+    ...(signoffNote !== undefined ? { signoffNote } : {}),
+    items: resolveChecklistItemSignoffItems(itemsJson),
+  };
+}
+
 function resolveRecordAuditCatalogEntryEvidenceInput(
   flags: ReadonlyMap<string, string | boolean>,
 ): RecordAuditCatalogEntryEvidenceInput {
@@ -1205,6 +1266,32 @@ function resolveChecklistItemAcknowledgmentItems(itemsJson: string): readonly {
   return parsedItems;
 }
 
+function resolveChecklistItemSignoffItems(itemsJson: string): readonly {
+  readonly item: string;
+  readonly state: "signed-off" | "unsigned";
+}[] {
+  const parsedItems = JSON.parse(itemsJson) as unknown;
+
+  if (
+    !Array.isArray(parsedItems) ||
+    !parsedItems.every(
+      (item) =>
+        typeof item === "object" &&
+        item !== null &&
+        "item" in item &&
+        typeof item.item === "string" &&
+        "state" in item &&
+        (item.state === "signed-off" || item.state === "unsigned"),
+    )
+  ) {
+    throw new Error(
+      "--items-json must decode to an array of { item, state } objects with state signed-off|unsigned.",
+    );
+  }
+
+  return parsedItems;
+}
+
 function getStringFlag(
   flags: ReadonlyMap<string, string | boolean>,
   name: string,
@@ -1317,6 +1404,7 @@ Commands:
   audit catalog evidenced
   audit catalog attested
   audit catalog acknowledged
+  audit catalog signed-off
   audit catalog checklisted
   audit catalog progressed
   audit catalog publish <saved-view-id> [--name <name>] [--description <text>]
@@ -1329,6 +1417,7 @@ Commands:
   audit catalog inspect-evidence <catalog-entry-id>
   audit catalog inspect-attestation <catalog-entry-id>
   audit catalog inspect-acknowledgment <catalog-entry-id>
+  audit catalog inspect-sign-off <catalog-entry-id>
   audit catalog inspect-checklist <catalog-entry-id>
   audit catalog inspect-progress <catalog-entry-id>
   audit catalog inspect-review <catalog-entry-id>
@@ -1339,6 +1428,7 @@ Commands:
   audit catalog record-evidence <catalog-entry-id> --items-json <json-array> [--evidence-note <text>]
   audit catalog attest <catalog-entry-id> --items-json <json-array> [--attestation-note <text>]
   audit catalog acknowledge <catalog-entry-id> --items-json <json-array> [--acknowledgment-note <text>]
+  audit catalog sign-off <catalog-entry-id> --items-json <json-array> [--signoff-note <text>]
   audit catalog checklist <catalog-entry-id> --status <pending|completed> [--items-json <json-array>]
   audit catalog progress <catalog-entry-id> --items-json <json-array> [--completion-note <text>]
   audit catalog clear-blocker <catalog-entry-id>
@@ -1347,6 +1437,7 @@ Commands:
   audit catalog clear-evidence <catalog-entry-id>
   audit catalog clear-attestation <catalog-entry-id>
   audit catalog clear-acknowledgment <catalog-entry-id>
+  audit catalog clear-sign-off <catalog-entry-id>
   audit catalog clear-assignment <catalog-entry-id>
   audit catalog clear-checklist <catalog-entry-id>
   audit catalog clear-progress <catalog-entry-id>
diff --git a/packages/config/src/index.test.ts b/packages/config/src/index.test.ts
index e36ca39..4fb45ce 100644
--- a/packages/config/src/index.test.ts
+++ b/packages/config/src/index.test.ts
@@ -11,9 +11,9 @@ import {
 describe("@runroot/config", () => {
   it("exposes phase-aware project metadata", () => {
     expect(projectMetadata.name).toBe("Runroot");
-    expect(projectMetadata.currentPhase).toBe(27);
+    expect(projectMetadata.currentPhase).toBe(28);
     expect(projectMetadata.phaseName).toBe(
-      "Cross-Run Audit Catalog Checklist Item Acknowledgments and Acknowledgment Notes",
+      "Cross-Run Audit Catalog Checklist Item Sign-Offs and Sign-Off Notes",
     );
   });
 
diff --git a/packages/config/src/index.ts b/packages/config/src/index.ts
index 06b7c24..3e0f641 100644
--- a/packages/config/src/index.ts
+++ b/packages/config/src/index.ts
@@ -27,7 +27,8 @@ export type DeliveryPhase =
   | 24
   | 25
   | 26
-  | 27;
+  | 27
+  | 28;
 
 export type ExecutionMode = "inline" | "queued";
 
@@ -85,9 +86,9 @@ export const projectMetadata = {
   name: "Runroot",
   description:
     "MCP-native runtime and orchestration for durable developer and ops workflows.",
-  currentPhase: 27,
+  currentPhase: 28,
   phaseName:
-    "Cross-Run Audit Catalog Checklist Item Acknowledgments and Acknowledgment Notes",
+    "Cross-Run Audit Catalog Checklist Item Sign-Offs and Sign-Off Notes",
 } as const;
 
 export const requiredQualityCommands = [
diff --git a/packages/persistence/src/catalog-checklist-item-signoff-store.test.ts b/packages/persistence/src/catalog-checklist-item-signoff-store.test.ts
new file mode 100644
index 0000000..d1e7b95
--- /dev/null
+++ b/packages/persistence/src/catalog-checklist-item-signoff-store.test.ts
@@ -0,0 +1,137 @@
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { createCrossRunAuditCatalogChecklistItemSignoff } from "@runroot/replay";
+import { newDb } from "pg-mem";
+import { describe, expect, it } from "vitest";
+
+import {
+  createFileAuditCatalogChecklistItemSignoffStore,
+  createPostgresAuditCatalogChecklistItemSignoffStore,
+  createSqliteAuditCatalogChecklistItemSignoffStore,
+  resolveAuditCatalogChecklistItemSignoffFilePath,
+} from "./catalog-checklist-item-signoff-store";
+
+function createSignoff(
+  catalogEntryId: string,
+  timestamp = "2026-04-02T04:15:00.000Z",
+  signoffNote = "Operator signed-off that the cited evidence is sufficient",
+) {
+  return createCrossRunAuditCatalogChecklistItemSignoff({
+    signoffNote,
+    catalogEntryId,
+    items: [
+      {
+        item: "Validate queued follow-up",
+        state: "signed-off",
+      },
+      {
+        item: "Close backup handoff",
+        state: "unsigned",
+      },
+    ],
+    operatorId: "ops_oncall",
+    scopeId: "ops",
+    timestamp,
+  });
+}
+
+describe("@runroot/persistence audit catalog checklist item signoff stores", () => {
+  it("persists audit catalog checklist item signoff through the Postgres adapter", async () => {
+    const memoryDatabase = newDb({
+      noAstCoverageCheck: true,
+    });
+    const { Pool } = memoryDatabase.adapters.createPg();
+    const pool = new Pool();
+    const firstStore = createPostgresAuditCatalogChecklistItemSignoffStore({
+      pool,
+    });
+    const secondStore = createPostgresAuditCatalogChecklistItemSignoffStore({
+      pool,
+    });
+
+    try {
+      await firstStore.saveCatalogChecklistItemSignoff(
+        createSignoff("catalog_entry_postgres"),
+      );
+
+      expect(await secondStore.listCatalogChecklistItemSignoffs()).toEqual([
+        createSignoff("catalog_entry_postgres"),
+      ]);
+    } finally {
+      await pool.end();
+    }
+  });
+
+  it("persists audit catalog checklist item signoff through the SQLite adapter", async () => {
+    const workspaceRoot = await mkdtemp(
+      join(tmpdir(), "runroot-signoff-sqlite-"),
+    );
+    const filePath = join(workspaceRoot, "runroot.sqlite");
+    const firstStore = createSqliteAuditCatalogChecklistItemSignoffStore({
+      filePath,
+    });
+    const secondStore = createSqliteAuditCatalogChecklistItemSignoffStore({
+      filePath,
+    });
+
+    await firstStore.saveCatalogChecklistItemSignoff(
+      createSignoff("catalog_entry_sqlite"),
+    );
+
+    expect(await secondStore.listCatalogChecklistItemSignoffs()).toEqual([
+      createSignoff("catalog_entry_sqlite"),
+    ]);
+  });
+
+  it("persists audit catalog checklist item signoff through the file-sidecar compatibility path", async () => {
+    const workspaceRoot = await mkdtemp(
+      join(tmpdir(), "runroot-signoff-file-"),
+    );
+    const workspacePath = join(workspaceRoot, "workspace.json");
+    const fileStore = createFileAuditCatalogChecklistItemSignoffStore({
+      filePath: resolveAuditCatalogChecklistItemSignoffFilePath(workspacePath),
+    });
+
+    await fileStore.saveCatalogChecklistItemSignoff(
+      createSignoff("catalog_entry_file"),
+    );
+
+    expect(await fileStore.listCatalogChecklistItemSignoffs()).toEqual([
+      createSignoff("catalog_entry_file"),
+    ]);
+  });
+
+  it("overwrites and clears audit catalog checklist item signoff through the file-sidecar compatibility path", async () => {
+    const workspaceRoot = await mkdtemp(
+      join(tmpdir(), "runroot-signoff-file-overwrite-"),
+    );
+    const workspacePath = join(workspaceRoot, "workspace.json");
+    const fileStore = createFileAuditCatalogChecklistItemSignoffStore({
+      filePath: resolveAuditCatalogChecklistItemSignoffFilePath(workspacePath),
+    });
+    const originalEntry = createSignoff("catalog_entry_overwrite");
+    const updatedEntry = createSignoff(
+      "catalog_entry_overwrite",
+      "2026-04-02T04:15:10.000Z",
+      "Operator re-signed-off the evidence after the queued handoff",
+    );
+
+    await fileStore.saveCatalogChecklistItemSignoff(originalEntry);
+    await fileStore.saveCatalogChecklistItemSignoff(updatedEntry);
+
+    expect(
+      await fileStore.getCatalogChecklistItemSignoff("catalog_entry_overwrite"),
+    ).toEqual(updatedEntry);
+    expect(await fileStore.listCatalogChecklistItemSignoffs()).toEqual([
+      updatedEntry,
+    ]);
+    expect(
+      await fileStore.deleteCatalogChecklistItemSignoff(
+        "catalog_entry_overwrite",
+      ),
+    ).toEqual(updatedEntry);
+    expect(await fileStore.listCatalogChecklistItemSignoffs()).toEqual([]);
+  });
+});
diff --git a/packages/persistence/src/catalog-checklist-item-signoff-store.ts b/packages/persistence/src/catalog-checklist-item-signoff-store.ts
new file mode 100644
index 0000000..68b4543
--- /dev/null
+++ b/packages/persistence/src/catalog-checklist-item-signoff-store.ts
@@ -0,0 +1,865 @@
+import { mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join, parse, resolve } from "node:path";
+
+import {
+  type ResolvePersistenceConfigOptions,
+  resolvePersistenceConfig,
+} from "@runroot/config";
+import type {
+  CrossRunAuditCatalogChecklistItemSignoff,
+  CrossRunAuditCatalogChecklistItemSignoffStore,
+} from "@runroot/replay";
+import { compareCrossRunAuditCatalogChecklistItemSignoff } from "@runroot/replay";
+import type { Pool, PoolClient } from "pg";
+import type {
+  BindParams,
+  Database as SqliteDatabase,
+  SqlJsStatic,
+} from "sql.js";
+import initSqlJs from "sql.js/dist/sql-asm.js";
+
+import {
+  migratePostgresPersistence,
+  migrateSqlitePersistence,
+  type PostgresRuntimePersistenceOptions,
+  type SqliteRuntimePersistenceOptions,
+} from "./database-store";
+
+type SqlPrimitive = number | string | null;
+type SqlQueryRow = Readonly<Record<string, unknown>>;
+
+interface SqlClient {
+  readonly dialect: "postgres" | "sqlite";
+  execute(sql: string, params?: readonly SqlPrimitive[]): Promise<number>;
+  queryRows<TRow extends SqlQueryRow>(
+    sql: string,
+    params?: readonly SqlPrimitive[],
+  ): Promise<readonly TRow[]>;
+}
+
+type PostgresPoolLike = Pick<Pool, "connect">;
+
+export interface InMemoryAuditCatalogChecklistItemSignoffStoreOptions {
+  readonly signoffEntries?: readonly CrossRunAuditCatalogChecklistItemSignoff[];
+}
+
+export interface FileAuditCatalogChecklistItemSignoffStoreOptions {
+  readonly filePath: string;
+  readonly lockRetryDelayMs?: number;
+  readonly lockTimeoutMs?: number;
+}
+
+export interface PostgresAuditCatalogChecklistItemSignoffStoreOptions
+  extends Pick<PostgresRuntimePersistenceOptions, "databaseUrl" | "pool"> {}
+
+export interface SqliteAuditCatalogChecklistItemSignoffStoreOptions
+  extends Pick<
+    SqliteRuntimePersistenceOptions,
+    "filePath" | "lockRetryDelayMs" | "lockTimeoutMs"
+  > {}
+
+export interface ConfiguredAuditCatalogChecklistItemSignoffStoreOptions
+  extends ResolvePersistenceConfigOptions {
+  readonly filePath?: string;
+  readonly lockRetryDelayMs?: number;
+  readonly lockTimeoutMs?: number;
+  readonly pool?: PostgresPoolLike;
+}
+
+interface AuditCatalogChecklistItemSignoffSnapshot {
+  readonly signoffEntries: readonly CrossRunAuditCatalogChecklistItemSignoff[];
+}
+
+let sqliteModulePromise: Promise<SqlJsStatic> | undefined;
+
+export function createConfiguredAuditCatalogChecklistItemSignoffStore(
+  options: ConfiguredAuditCatalogChecklistItemSignoffStoreOptions = {},
+): CrossRunAuditCatalogChecklistItemSignoffStore {
+  const resolved = resolvePersistenceConfig(options);
+
+  switch (resolved.driver) {
+    case "file":
+      return createFileAuditCatalogChecklistItemSignoffStore({
+        filePath:
+          options.filePath ??
+          resolveAuditCatalogChecklistItemSignoffFilePath(
+            resolved.workspacePath ?? resolved.location,
+          ),
+        ...(options.lockRetryDelayMs !== undefined
+          ? { lockRetryDelayMs: options.lockRetryDelayMs }
+          : {}),
+        ...(options.lockTimeoutMs !== undefined
+          ? { lockTimeoutMs: options.lockTimeoutMs }
+          : {}),
+      });
+    case "postgres":
+      return createPostgresAuditCatalogChecklistItemSignoffStore({
+        ...(resolved.databaseUrl ? { databaseUrl: resolved.databaseUrl } : {}),
+        ...(options.pool ? { pool: options.pool } : {}),
+      });
+    case "sqlite":
+      return createSqliteAuditCatalogChecklistItemSignoffStore({
+        filePath: resolved.sqlitePath ?? resolved.location,
+        ...(options.lockRetryDelayMs !== undefined
+          ? { lockRetryDelayMs: options.lockRetryDelayMs }
+          : {}),
+        ...(options.lockTimeoutMs !== undefined
+          ? { lockTimeoutMs: options.lockTimeoutMs }
+          : {}),
+      });
+  }
+}
+
+export function createInMemoryAuditCatalogChecklistItemSignoffStore(
+  options: InMemoryAuditCatalogChecklistItemSignoffStoreOptions = {},
+): CrossRunAuditCatalogChecklistItemSignoffStore {
+  const signoffEntries = [...(options.signoffEntries ?? [])].map((entry) =>
+    clone(entry),
+  );
+
+  return {
+    async deleteCatalogChecklistItemSignoff(catalogEntryId) {
+      const existingIndex = signoffEntries.findIndex(
+        (entry) => entry.catalogEntryId === catalogEntryId,
+      );
+
+      if (existingIndex < 0) {
+        return undefined;
+      }
+
+      const [deletedEntry] = signoffEntries.splice(existingIndex, 1);
+
+      return deletedEntry ? clone(deletedEntry) : undefined;
+    },
+
+    async getCatalogChecklistItemSignoff(catalogEntryId) {
+      const signoff = signoffEntries.find(
+        (entry) => entry.catalogEntryId === catalogEntryId,
+      );
+
+      return signoff ? clone(signoff) : undefined;
+    },
+
+    async listCatalogChecklistItemSignoffs() {
+      return signoffEntries
+        .slice()
+        .sort(compareCrossRunAuditCatalogChecklistItemSignoff)
+        .map((entry) => clone(entry));
+    },
+
+    async saveCatalogChecklistItemSignoff(entry) {
+      const existingIndex = signoffEntries.findIndex(
+        (candidate) => candidate.catalogEntryId === entry.catalogEntryId,
+      );
+
+      if (existingIndex >= 0) {
+        signoffEntries.splice(existingIndex, 1);
+      }
+
+      signoffEntries.push(clone(entry));
+      signoffEntries.sort(compareCrossRunAuditCatalogChecklistItemSignoff);
+
+      return clone(entry);
+    },
+  };
+}
+
+export function createFileAuditCatalogChecklistItemSignoffStore(
+  options: FileAuditCatalogChecklistItemSignoffStoreOptions,
+): CrossRunAuditCatalogChecklistItemSignoffStore {
+  const filePath = resolve(options.filePath);
+  let accessQueue = Promise.resolve();
+
+  return {
+    async deleteCatalogChecklistItemSignoff(catalogEntryId) {
+      return enqueueAccess(async () =>
+        withMutableSnapshot(filePath, options, async (snapshot) => {
+          const existingEntry = snapshot.signoffEntries.find(
+            (entry) => entry.catalogEntryId === catalogEntryId,
+          );
+
+          if (!existingEntry) {
+            return undefined;
+          }
+
+          await writeAuditCatalogChecklistItemSignoffSnapshot(filePath, {
+            signoffEntries: snapshot.signoffEntries.filter(
+              (entry) => entry.catalogEntryId !== catalogEntryId,
+            ),
+          });
+
+          return clone(existingEntry);
+        }),
+      );
+    },
+
+    async getCatalogChecklistItemSignoff(catalogEntryId) {
+      return enqueueAccess(async () =>
+        withReadOnlySnapshot(filePath, (snapshot) => {
+          const signoff = snapshot.signoffEntries.find(
+            (entry) => entry.catalogEntryId === catalogEntryId,
+          );
+
+          return signoff ? clone(signoff) : undefined;
+        }),
+      );
+    },
+
+    async listCatalogChecklistItemSignoffs() {
+      return enqueueAccess(async () =>
+        withReadOnlySnapshot(filePath, (snapshot) =>
+          snapshot.signoffEntries
+            .slice()
+            .sort(compareCrossRunAuditCatalogChecklistItemSignoff)
+            .map((entry) => clone(entry)),
+        ),
+      );
+    },
+
+    async saveCatalogChecklistItemSignoff(entry) {
+      return enqueueAccess(async () =>
+        withMutableSnapshot(filePath, options, async (snapshot) => {
+          const nextSignoffEntries = [
+            ...snapshot.signoffEntries.filter(
+              (candidate) => candidate.catalogEntryId !== entry.catalogEntryId,
+            ),
+            clone(entry),
+          ].sort(compareCrossRunAuditCatalogChecklistItemSignoff);
+
+          await writeAuditCatalogChecklistItemSignoffSnapshot(filePath, {
+            signoffEntries: nextSignoffEntries,
+          });
+
+          return clone(entry);
+        }),
+      );
+    },
+  };
+
+  async function enqueueAccess<TValue>(
+    accessOperation: () => Promise<TValue>,
+  ): Promise<TValue> {
+    const pendingAccess = accessQueue.then(accessOperation, accessOperation);
+    accessQueue = pendingAccess.then(
+      () => undefined,
+      () => undefined,
+    );
+
+    return pendingAccess;
+  }
+}
+
+export function createPostgresAuditCatalogChecklistItemSignoffStore(
+  options: PostgresAuditCatalogChecklistItemSignoffStoreOptions = {},
+): CrossRunAuditCatalogChecklistItemSignoffStore {
+  const pool = options.pool ?? createDefaultPool(options.databaseUrl);
+  let schemaReadyPromise: Promise<void> | undefined;
+
+  return createDatabaseAuditCatalogChecklistItemSignoffStore({
+    ensureSchema() {
+      schemaReadyPromise ??= migratePostgresPersistence({
+        ...(options.databaseUrl ? { databaseUrl: options.databaseUrl } : {}),
+        ...(options.pool ? { pool: options.pool } : {}),
+      }).then(() => undefined);
+
+      return schemaReadyPromise;
+    },
+    withReadOnlyClient(task) {
+      return withPostgresClient(pool, task);
+    },
+    withTransaction(task) {
+      return withPostgresTransaction(pool, task);
+    },
+  });
+}
+
+export function createSqliteAuditCatalogChecklistItemSignoffStore(
+  options: SqliteAuditCatalogChecklistItemSignoffStoreOptions,
+): CrossRunAuditCatalogChecklistItemSignoffStore {
+  const filePath = resolve(options.filePath);
+  let accessQueue = Promise.resolve();
+  let schemaReadyPromise: Promise<void> | undefined;
+
+  return createDatabaseAuditCatalogChecklistItemSignoffStore({
+    ensureSchema() {
+      schemaReadyPromise ??= migrateSqlitePersistence({
+        filePath,
+      }).then(() => undefined);
+
+      return schemaReadyPromise;
+    },
+    withReadOnlyClient(task) {
+      return enqueueAccess(async () =>
+        withSqliteClient(
+          {
+            filePath,
+            mutable: false,
+          },
+          task,
+        ),
+      );
+    },
+    withTransaction(task) {
+      return enqueueAccess(async () =>
+        withFileLock(filePath, options, async () =>
+          withSqliteClient(
+            {
+              filePath,
+              mutable: true,
+            },
+            task,
+          ),
+        ),
+      );
+    },
+  });
+
+  async function enqueueAccess<TValue>(
+    action: () => Promise<TValue>,
+  ): Promise<TValue> {
+    const pendingAccess = accessQueue.then(action, action);
+    accessQueue = pendingAccess.then(
+      () => undefined,
+      () => undefined,
+    );
+
+    return pendingAccess;
+  }
+}
+
+function createDatabaseAuditCatalogChecklistItemSignoffStore(options: {
+  readonly ensureSchema: () => Promise<void>;
+  readonly withReadOnlyClient: <TValue>(
+    task: (client: SqlClient) => Promise<TValue>,
+  ) => Promise<TValue>;
+  readonly withTransaction: <TValue>(
+    task: (client: SqlClient) => Promise<TValue>,
+  ) => Promise<TValue>;
+}): CrossRunAuditCatalogChecklistItemSignoffStore {
+  return {
+    async deleteCatalogChecklistItemSignoff(catalogEntryId) {
+      await options.ensureSchema();
+
+      return options.withTransaction(async (client) => {
+        const existingRows = await client.queryRows<{ data: string }>(
+          `SELECT data
+           FROM runroot_audit_catalog_checklist_item_signoff
+           WHERE catalog_entry_id = ?`,
+          [catalogEntryId],
+        );
+
+        if (!existingRows[0]) {
+          return undefined;
+        }
+
+        await client.execute(
+          `DELETE FROM runroot_audit_catalog_checklist_item_signoff
+           WHERE catalog_entry_id = ?`,
+          [catalogEntryId],
+        );
+
+        return deserializeRow<CrossRunAuditCatalogChecklistItemSignoff>(
+          existingRows[0].data,
+        );
+      });
+    },
+
+    async getCatalogChecklistItemSignoff(catalogEntryId) {
+      await options.ensureSchema();
+
+      return options.withReadOnlyClient(async (client) => {
+        const rows = await client.queryRows<{ data: string }>(
+          `SELECT data
+           FROM runroot_audit_catalog_checklist_item_signoff
+           WHERE catalog_entry_id = ?`,
+          [catalogEntryId],
+        );
+
+        return rows[0]
+          ? deserializeRow<CrossRunAuditCatalogChecklistItemSignoff>(
+              rows[0].data,
+            )
+          : undefined;
+      });
+    },
+
+    async listCatalogChecklistItemSignoffs() {
+      await options.ensureSchema();
+
+      return options.withReadOnlyClient(async (client) => {
+        const rows = await client.queryRows<{ data: string }>(
+          `SELECT data
+           FROM runroot_audit_catalog_checklist_item_signoff`,
+        );
+
+        return rows
+          .map((row) =>
+            deserializeRow<CrossRunAuditCatalogChecklistItemSignoff>(row.data),
+          )
+          .sort(compareCrossRunAuditCatalogChecklistItemSignoff);
+      });
+    },
+
+    async saveCatalogChecklistItemSignoff(entry) {
+      await options.ensureSchema();
+
+      return options.withTransaction(async (client) => {
+        await client.execute(
+          `INSERT INTO runroot_audit_catalog_checklist_item_signoff (
+             catalog_entry_id,
+             kind,
+             operator_id,
+             scope_id,
+             signoff_note,
+             signoff_items,
+             created_at,
+             updated_at,
+             data
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT (catalog_entry_id) DO UPDATE SET
+             kind = excluded.kind,
+             operator_id = excluded.operator_id,
+             scope_id = excluded.scope_id,
+             signoff_note = excluded.signoff_note,
+             signoff_items = excluded.signoff_items,
+             created_at = excluded.created_at,
+             updated_at = excluded.updated_at,
+             data = excluded.data`,
+          [
+            entry.catalogEntryId,
+            entry.kind,
+            entry.operatorId,
+            entry.scopeId,
+            entry.signoffNote ?? null,
+            JSON.stringify(entry.items),
+            entry.createdAt,
+            entry.updatedAt,
+            serializeRow(entry),
+          ],
+        );
+
+        return clone(entry);
+      });
+    },
+  };
+}
+
+export function resolveAuditCatalogChecklistItemSignoffFilePath(
+  workspacePath: string,
+): string {
+  const resolvedPath = resolve(workspacePath);
+  const parsedPath = parse(resolvedPath);
+
+  return join(
+    parsedPath.dir,
+    `${parsedPath.name}.audit-catalog-checklist-item-signoff.json`,
+  );
+}
+
+async function withReadOnlySnapshot<TValue>(
+  filePath: string,
+  action: (
+    snapshot: AuditCatalogChecklistItemSignoffSnapshot,
+  ) => TValue | Promise<TValue>,
+): Promise<TValue> {
+  const snapshot = await readAuditCatalogChecklistItemSignoffSnapshot(filePath);
+
+  return action(snapshot);
+}
+
+async function withMutableSnapshot<TValue>(
+  filePath: string,
+  options: Pick<
+    FileAuditCatalogChecklistItemSignoffStoreOptions,
+    "lockRetryDelayMs" | "lockTimeoutMs"
+  >,
+  action: (
+    snapshot: AuditCatalogChecklistItemSignoffSnapshot,
+  ) => Promise<TValue>,
+): Promise<TValue> {
+  await ensureParentDirectory(filePath);
+
+  return withFileLock(filePath, options, async () =>
+    action(await readAuditCatalogChecklistItemSignoffSnapshot(filePath)),
+  );
+}
+
+async function readAuditCatalogChecklistItemSignoffSnapshot(
+  filePath: string,
+): Promise<AuditCatalogChecklistItemSignoffSnapshot> {
+  try {
+    const rawSnapshot = await readFile(filePath, "utf8");
+    const parsedSnapshot = JSON.parse(
+      rawSnapshot,
+    ) as AuditCatalogChecklistItemSignoffSnapshot;
+
+    return {
+      signoffEntries: [...(parsedSnapshot.signoffEntries ?? [])].map((entry) =>
+        clone(entry),
+      ),
+    };
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return {
+        signoffEntries: [],
+      };
+    }
+
+    throw error;
+  }
+}
+
+async function writeAuditCatalogChecklistItemSignoffSnapshot(
+  filePath: string,
+  snapshot: AuditCatalogChecklistItemSignoffSnapshot,
+): Promise<void> {
+  const tempPath = `${filePath}.tmp`;
+  const backupPath = `${filePath}.bak`;
+
+  await writeFile(tempPath, `${JSON.stringify(snapshot, null, 2)}\n`, "utf8");
+
+  try {
+    await rename(tempPath, filePath);
+
+    return;
+  } catch (error) {
+    if (!isExistingFileError(error)) {
+      throw error;
+    }
+  }
+
+  await rm(backupPath, {
+    force: true,
+  });
+
+  try {
+    await rename(filePath, backupPath);
+    await rename(tempPath, filePath);
+  } catch (error) {
+    await rm(tempPath, {
+      force: true,
+    });
+
+    try {
+      await rename(backupPath, filePath);
+    } catch (restoreError) {
+      if (!isMissingFileError(restoreError)) {
+        throw restoreError;
+      }
+    }
+
+    throw error;
+  }
+
+  await rm(backupPath, {
+    force: true,
+  });
+}
+
+async function withPostgresClient<TValue>(
+  pool: PostgresPoolLike,
+  task: (client: SqlClient) => Promise<TValue>,
+): Promise<TValue> {
+  const client = await pool.connect();
+
+  try {
+    return await task(new PostgresSqlClient(client));
+  } finally {
+    client.release();
+  }
+}
+
+async function withPostgresTransaction<TValue>(
+  pool: PostgresPoolLike,
+  task: (client: SqlClient) => Promise<TValue>,
+): Promise<TValue> {
+  const client = await pool.connect();
+
+  try {
+    await client.query("BEGIN");
+    const result = await task(new PostgresSqlClient(client));
+    await client.query("COMMIT");
+
+    return result;
+  } catch (error) {
+    await client.query("ROLLBACK");
+
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+
+async function withSqliteClient<TValue>(
+  options: {
+    readonly filePath: string;
+    readonly mutable: boolean;
+  },
+  task: (client: SqlClient) => Promise<TValue>,
+): Promise<TValue> {
+  if (options.mutable) {
+    await ensureParentDirectory(options.filePath);
+  }
+
+  const SQL = await loadSqliteModule();
+  const database = await openSqliteDatabase(SQL, options.filePath);
+
+  try {
+    const client = new SqliteSqlClient(database);
+
+    if (!options.mutable) {
+      return task(client);
+    }
+
+    await client.execute("BEGIN");
+
+    try {
+      const result = await task(client);
+      await client.execute("COMMIT");
+      await writeBinaryFileAtomically(options.filePath, database.export());
+
+      return result;
+    } catch (error) {
+      await client.execute("ROLLBACK");
+
+      throw error;
+    }
+  } finally {
+    database.close();
+  }
+}
+
+async function openSqliteDatabase(
+  SQL: SqlJsStatic,
+  filePath: string,
+): Promise<SqliteDatabase> {
+  try {
+    const contents = await readFile(filePath);
+
+    return new SQL.Database(new Uint8Array(contents));
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return new SQL.Database();
+    }
+
+    throw error;
+  }
+}
+
+async function loadSqliteModule(): Promise<SqlJsStatic> {
+  sqliteModulePromise ??= initSqlJs();
+
+  return sqliteModulePromise;
+}
+
+class PostgresSqlClient implements SqlClient {
+  readonly dialect = "postgres" as const;
+
+  constructor(private readonly client: PoolClient) {}
+
+  async execute(
+    sql: string,
+    params: readonly SqlPrimitive[] = [],
+  ): Promise<number> {
+    const result = await this.client.query(
+      convertQuestionMarksToPostgres(sql),
+      [...params],
+    );
+
+    return result.rowCount ?? 0;
+  }
+
+  async queryRows<TRow extends SqlQueryRow>(
+    sql: string,
+    params: readonly SqlPrimitive[] = [],
+  ): Promise<readonly TRow[]> {
+    const result = await this.client.query<TRow>(
+      convertQuestionMarksToPostgres(sql),
+      [...params],
+    );
+
+    return result.rows;
+  }
+}
+
+class SqliteSqlClient implements SqlClient {
+  readonly dialect = "sqlite" as const;
+
+  constructor(private readonly database: SqliteDatabase) {}
+
+  async execute(
+    sql: string,
+    params: readonly SqlPrimitive[] = [],
+  ): Promise<number> {
+    this.database.run(sql, toSqliteParams(params));
+
+    return this.database.getRowsModified();
+  }
+
+  async queryRows<TRow extends SqlQueryRow>(
+    sql: string,
+    params: readonly SqlPrimitive[] = [],
+  ): Promise<readonly TRow[]> {
+    const statement = this.database.prepare(sql, toSqliteParams(params));
+    const rows: TRow[] = [];
+
+    try {
+      while (statement.step()) {
+        rows.push(statement.getAsObject() as TRow);
+      }
+    } finally {
+      statement.free();
+    }
+
+    return rows;
+  }
+}
+
+function createDefaultPool(databaseUrl?: string): PostgresPoolLike {
+  if (!databaseUrl) {
+    throw new Error(
+      'Postgres audit catalog checklist item signoff requires DATABASE_URL or an explicit "databaseUrl" option.',
+    );
+  }
+
+  const { Pool } = require("pg") as typeof import("pg");
+
+  return new Pool({
+    connectionString: databaseUrl,
+  });
+}
+
+function toSqliteParams(params: readonly SqlPrimitive[]): BindParams {
+  return [...params];
+}
+
+function convertQuestionMarksToPostgres(sql: string): string {
+  let placeholderIndex = 0;
+
+  return sql.replace(/\?/g, () => `$${++placeholderIndex}`);
+}
+
+async function ensureParentDirectory(filePath: string): Promise<void> {
+  await mkdir(dirname(filePath), {
+    recursive: true,
+  });
+}
+
+async function writeBinaryFileAtomically(
+  filePath: string,
+  contents: Uint8Array,
+): Promise<void> {
+  const tempPath = `${filePath}.tmp`;
+  const backupPath = `${filePath}.bak`;
+
+  await writeFile(tempPath, Buffer.from(contents));
+
+  try {
+    await rename(tempPath, filePath);
+
+    return;
+  } catch (error) {
+    if (!isExistingFileError(error)) {
+      throw error;
+    }
+  }
+
+  await rm(backupPath, {
+    force: true,
+  });
+
+  try {
+    await rename(filePath, backupPath);
+    await rename(tempPath, filePath);
+  } catch (error) {
+    await rm(tempPath, {
+      force: true,
+    });
+
+    try {
+      await rename(backupPath, filePath);
+    } catch (restoreError) {
+      if (!isMissingFileError(restoreError)) {
+        throw restoreError;
+      }
+    }
+
+    throw error;
+  }
+
+  await rm(backupPath, {
+    force: true,
+  });
+}
+
+async function withFileLock<TValue>(
+  filePath: string,
+  options: Pick<
+    | FileAuditCatalogChecklistItemSignoffStoreOptions
+    | SqliteAuditCatalogChecklistItemSignoffStoreOptions,
+    "lockRetryDelayMs" | "lockTimeoutMs"
+  >,
+  action: () => Promise<TValue>,
+): Promise<TValue> {
+  const lockPath = `${filePath}.lock`;
+  const retryDelayMs = options.lockRetryDelayMs ?? 25;
+  const timeoutMs = options.lockTimeoutMs ?? 5_000;
+  const startedAt = Date.now();
+
+  while (true) {
+    try {
+      const lockHandle = await open(lockPath, "wx");
+
+      try {
+        return await action();
+      } finally {
+        await lockHandle.close();
+        await rm(lockPath, {
+          force: true,
+        });
+      }
+    } catch (error) {
+      if (!isExistingFileError(error)) {
+        throw error;
+      }
+
+      if (Date.now() - startedAt >= timeoutMs) {
+        throw new Error(
+          `Timed out waiting for audit catalog checklist item signoff lock at "${lockPath}".`,
+        );
+      }
+
+      await delay(retryDelayMs);
+    }
+  }
+}
+
+function delay(durationMs: number): Promise<void> {
+  return new Promise((resolveDelay) => {
+    setTimeout(resolveDelay, durationMs);
+  });
+}
+
+function serializeRow(value: unknown): string {
+  return JSON.stringify(value);
+}
+
+function deserializeRow<TValue>(rawValue: string): TValue {
+  return JSON.parse(rawValue) as TValue;
+}
+
+function clone<TValue>(value: TValue): TValue {
+  return structuredClone(value);
+}
+
+function isExistingFileError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    (error.code === "EEXIST" || error.code === "EPERM")
+  );
+}
+
+function isMissingFileError(error: unknown): boolean {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
diff --git a/packages/persistence/src/index.ts b/packages/persistence/src/index.ts
index d2eebd7..5d3b4a3 100644
--- a/packages/persistence/src/index.ts
+++ b/packages/persistence/src/index.ts
@@ -91,6 +91,19 @@ export {
   resolveAuditCatalogChecklistItemResolutionsFilePath,
   type SqliteAuditCatalogChecklistItemResolutionStoreOptions,
 } from "./catalog-checklist-item-resolution-store";
+export {
+  type ConfiguredAuditCatalogChecklistItemSignoffStoreOptions,
+  createConfiguredAuditCatalogChecklistItemSignoffStore,
+  createFileAuditCatalogChecklistItemSignoffStore,
+  createInMemoryAuditCatalogChecklistItemSignoffStore,
+  createPostgresAuditCatalogChecklistItemSignoffStore,
+  createSqliteAuditCatalogChecklistItemSignoffStore,
+  type FileAuditCatalogChecklistItemSignoffStoreOptions,
+  type InMemoryAuditCatalogChecklistItemSignoffStoreOptions,
+  type PostgresAuditCatalogChecklistItemSignoffStoreOptions,
+  resolveAuditCatalogChecklistItemSignoffFilePath,
+  type SqliteAuditCatalogChecklistItemSignoffStoreOptions,
+} from "./catalog-checklist-item-signoff-store";
 export {
   type ConfiguredAuditCatalogChecklistItemVerificationStoreOptions,
   createConfiguredAuditCatalogChecklistItemVerificationStore,
diff --git a/packages/persistence/src/migrations.ts b/packages/persistence/src/migrations.ts
index 4213ad1..61dcca7 100644
--- a/packages/persistence/src/migrations.ts
+++ b/packages/persistence/src/migrations.ts
@@ -628,6 +628,43 @@ export const runtimePersistenceMigrations = [
         ON runroot_audit_catalog_checklist_item_attestation (operator_id, updated_at DESC, catalog_entry_id ASC)`,
     ],
   },
+  {
+    id: "0017_audit_catalog_checklist_item_signoff",
+    postgres: [
+      `CREATE TABLE IF NOT EXISTS runroot_audit_catalog_checklist_item_signoff (
+        catalog_entry_id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL,
+        operator_id TEXT NOT NULL,
+        scope_id TEXT NOT NULL,
+        signoff_note TEXT,
+        signoff_items TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        data TEXT NOT NULL
+      )`,
+      `CREATE INDEX IF NOT EXISTS idx_runroot_audit_catalog_checklist_item_signoff_scope
+        ON runroot_audit_catalog_checklist_item_signoff (scope_id, updated_at DESC, catalog_entry_id ASC)`,
+      `CREATE INDEX IF NOT EXISTS idx_runroot_audit_catalog_checklist_item_signoff_operator
+        ON runroot_audit_catalog_checklist_item_signoff (operator_id, updated_at DESC, catalog_entry_id ASC)`,
+    ],
+    sqlite: [
+      `CREATE TABLE IF NOT EXISTS runroot_audit_catalog_checklist_item_signoff (
+        catalog_entry_id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL,
+        operator_id TEXT NOT NULL,
+        scope_id TEXT NOT NULL,
+        signoff_note TEXT,
+        signoff_items TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        data TEXT NOT NULL
+      )`,
+      `CREATE INDEX IF NOT EXISTS idx_runroot_audit_catalog_checklist_item_signoff_scope
+        ON runroot_audit_catalog_checklist_item_signoff (scope_id, updated_at DESC, catalog_entry_id ASC)`,
+      `CREATE INDEX IF NOT EXISTS idx_runroot_audit_catalog_checklist_item_signoff_operator
+        ON runroot_audit_catalog_checklist_item_signoff (operator_id, updated_at DESC, catalog_entry_id ASC)`,
+    ],
+  },
   {
     id: "0016_audit_catalog_checklist_item_acknowledgment",
     postgres: [
diff --git a/packages/replay/src/checklist-item-signoff.test.ts b/packages/replay/src/checklist-item-signoff.test.ts
new file mode 100644
index 0000000..fab9a96
--- /dev/null
+++ b/packages/replay/src/checklist-item-signoff.test.ts
@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  compareCrossRunAuditCatalogChecklistItemSignoff,
+  createCrossRunAuditCatalogChecklistItemSignoff,
+  normalizeChecklistItemSignoffItems,
+} from "./checklist-item-signoff";
+
+describe("@runroot/replay audit catalog checklist item signoff", () => {
+  it("creates checklist item signoff with normalized metadata", () => {
+    const signoff = createCrossRunAuditCatalogChecklistItemSignoff({
+      signoffNote: " Evidence is sufficient for the queued closeout ",
+      catalogEntryId: " catalog_entry_signoff ",
+      items: [
+        {
+          item: "Validate queued follow-up",
+          state: "signed-off",
+        },
+        {
+          item: "Close backup handoff",
+          state: "unsigned",
+        },
+      ],
+      operatorId: " ops_oncall ",
+      scopeId: " ops ",
+      timestamp: "2026-04-02T04:00:00.000Z",
+    });
+
+    expect(signoff).toEqual({
+      signoffNote: "Evidence is sufficient for the queued closeout",
+      catalogEntryId: "catalog_entry_signoff",
+      createdAt: "2026-04-02T04:00:00.000Z",
+      items: [
+        {
+          item: "Validate queued follow-up",
+          state: "signed-off",
+        },
+        {
+          item: "Close backup handoff",
+          state: "unsigned",
+        },
+      ],
+      kind: "catalog-checklist-item-signoff",
+      operatorId: "ops_oncall",
+      scopeId: "ops",
+      updatedAt: "2026-04-02T04:00:00.000Z",
+    });
+  });
+
+  it("restricts checklist item signoff to shared acknowledgment items", () => {
+    expect(() =>
+      normalizeChecklistItemSignoffItems(
+        [
+          {
+            item: "Missing item",
+            state: "signed-off",
+          },
+        ],
+        ["Validate queued follow-up", "Close backup handoff"],
+      ),
+    ).toThrow(
+      'Catalog checklist item signoff "Missing item" is not defined on the shared checklist item acknowledgment layer.',
+    );
+  });
+
+  it("sorts newer signoff entries ahead of older signoff entries", () => {
+    const olderEntry = createCrossRunAuditCatalogChecklistItemSignoff({
+      catalogEntryId: "catalog_entry_older",
+      items: [
+        {
+          item: "Validate queued follow-up",
+          state: "signed-off",
+        },
+      ],
+      operatorId: "ops_oncall",
+      scopeId: "ops",
+      timestamp: "2026-04-02T04:00:00.000Z",
+    });
+    const newerEntry = createCrossRunAuditCatalogChecklistItemSignoff({
+      catalogEntryId: "catalog_entry_newer",
+      items: [
+        {
+          item: "Validate queued follow-up",
+          state: "signed-off",
+        },
+      ],
+      operatorId: "ops_oncall",
+      scopeId: "ops",
+      timestamp: "2026-04-02T04:00:01.000Z",
+    });
+
+    expect(
+      [olderEntry, newerEntry].sort(
+        compareCrossRunAuditCatalogChecklistItemSignoff,
+      ),
+    ).toEqual([newerEntry, olderEntry]);
+  });
+});
diff --git a/packages/replay/src/checklist-item-signoff.ts b/packages/replay/src/checklist-item-signoff.ts
new file mode 100644
index 0000000..18cd80a
--- /dev/null
+++ b/packages/replay/src/checklist-item-signoff.ts
@@ -0,0 +1,181 @@
+import type {
+  CrossRunAuditCatalogChecklistItemAcknowledgmentApplication,
+  CrossRunAuditCatalogChecklistItemAcknowledgmentView,
+} from "./checklist-item-acknowledgment";
+
+export type CrossRunAuditCatalogChecklistItemSignoffState =
+  | "signed-off"
+  | "unsigned";
+
+export interface CrossRunAuditCatalogChecklistItemSignoffItem {
+  readonly item: string;
+  readonly state: CrossRunAuditCatalogChecklistItemSignoffState;
+}
+
+export interface CrossRunAuditCatalogChecklistItemSignoff {
+  readonly signoffNote?: string;
+  readonly catalogEntryId: string;
+  readonly createdAt: string;
+  readonly items: readonly CrossRunAuditCatalogChecklistItemSignoffItem[];
+  readonly kind: "catalog-checklist-item-signoff";
+  readonly operatorId: string;
+  readonly scopeId: string;
+  readonly updatedAt: string;
+}
+
+export interface CreateCrossRunAuditCatalogChecklistItemSignoffInput {
+  readonly signoffNote?: string;
+  readonly catalogEntryId: string;
+  readonly items: readonly CrossRunAuditCatalogChecklistItemSignoffItem[];
+  readonly operatorId: string;
+  readonly scopeId: string;
+  readonly timestamp: string;
+}
+
+export interface UpdateCrossRunAuditCatalogChecklistItemSignoffInput {
+  readonly signoffNote?: string;
+  readonly items: readonly CrossRunAuditCatalogChecklistItemSignoffItem[];
+}
+
+export interface CrossRunAuditCatalogChecklistItemSignoffStore {
+  deleteCatalogChecklistItemSignoff(
+    catalogEntryId: string,
+  ): Promise<CrossRunAuditCatalogChecklistItemSignoff | undefined>;
+  getCatalogChecklistItemSignoff(
+    catalogEntryId: string,
+  ): Promise<CrossRunAuditCatalogChecklistItemSignoff | undefined>;
+  listCatalogChecklistItemSignoffs(): Promise<
+    readonly CrossRunAuditCatalogChecklistItemSignoff[]
+  >;
+  saveCatalogChecklistItemSignoff(
+    signoff: CrossRunAuditCatalogChecklistItemSignoff,
+  ): Promise<CrossRunAuditCatalogChecklistItemSignoff>;
+}
+
+export interface CrossRunAuditCatalogChecklistItemSignoffView {
+  readonly signoff: CrossRunAuditCatalogChecklistItemSignoff;
+  readonly acknowledgment: CrossRunAuditCatalogChecklistItemAcknowledgmentView;
+}
+
+export interface CrossRunAuditCatalogChecklistItemSignoffCollection {
+  readonly items: readonly CrossRunAuditCatalogChecklistItemSignoffView[];
+  readonly totalCount: number;
+}
+
+export interface CrossRunAuditCatalogChecklistItemSignoffApplication {
+  readonly application: CrossRunAuditCatalogChecklistItemAcknowledgmentApplication;
+  readonly signoff: CrossRunAuditCatalogChecklistItemSignoffView;
+}
+
+export function createCrossRunAuditCatalogChecklistItemSignoff(
+  input: CreateCrossRunAuditCatalogChecklistItemSignoffInput,
+): CrossRunAuditCatalogChecklistItemSignoff {
+  const catalogEntryId = input.catalogEntryId.trim();
+  const operatorId = input.operatorId.trim();
+  const scopeId = input.scopeId.trim();
+  const items = normalizeChecklistItemSignoffItems(input.items);
+  const signoffNote = normalizeSignoffNote(input.signoffNote);
+
+  if (catalogEntryId.length === 0) {
+    throw new Error(
+      "Catalog checklist item signoffs require a catalog entry id.",
+    );
+  }
+
+  if (operatorId.length === 0) {
+    throw new Error("Catalog checklist item signoffs require an operator id.");
+  }
+
+  if (scopeId.length === 0) {
+    throw new Error("Catalog checklist item signoffs require a scope id.");
+  }
+
+  if (items.length === 0) {
+    throw new Error(
+      "Catalog checklist item signoffs require at least one checklist item signoff entry.",
+    );
+  }
+
+  return {
+    ...(signoffNote ? { signoffNote } : {}),
+    catalogEntryId,
+    createdAt: input.timestamp,
+    items,
+    kind: "catalog-checklist-item-signoff",
+    operatorId,
+    scopeId,
+    updatedAt: input.timestamp,
+  };
+}
+
+export function compareCrossRunAuditCatalogChecklistItemSignoff(
+  left: CrossRunAuditCatalogChecklistItemSignoff,
+  right: CrossRunAuditCatalogChecklistItemSignoff,
+): number {
+  return (
+    compareSignoffPriority(left, right) ||
+    right.updatedAt.localeCompare(left.updatedAt) ||
+    right.createdAt.localeCompare(left.createdAt) ||
+    left.catalogEntryId.localeCompare(right.catalogEntryId)
+  );
+}
+
+export function normalizeChecklistItemSignoffItems(
+  items: readonly CrossRunAuditCatalogChecklistItemSignoffItem[] | undefined,
+  allowedItems?: readonly string[],
+): readonly CrossRunAuditCatalogChecklistItemSignoffItem[] {
+  const allowedItemSet = allowedItems
+    ? new Set(allowedItems.map((item) => item.trim()).filter(Boolean))
+    : undefined;
+  const dedupedItems = new Map<
+    string,
+    CrossRunAuditCatalogChecklistItemSignoffState
+  >();
+
+  for (const entry of items ?? []) {
+    const item = entry.item.trim();
+
+    if (item.length === 0) {
+      continue;
+    }
+
+    if (entry.state !== "signed-off" && entry.state !== "unsigned") {
+      throw new Error(
+        `Catalog checklist item signoffs require state signed-off|unsigned for "${item}".`,
+      );
+    }
+
+    if (allowedItemSet && !allowedItemSet.has(item)) {
+      throw new Error(
+        `Catalog checklist item signoff "${item}" is not defined on the shared checklist item acknowledgment layer.`,
+      );
+    }
+
+    dedupedItems.set(item, entry.state);
+  }
+
+  return [...dedupedItems.entries()].map(([item, state]) => ({
+    item,
+    state,
+  }));
+}
+
+function compareSignoffPriority(
+  left: CrossRunAuditCatalogChecklistItemSignoff,
+  right: CrossRunAuditCatalogChecklistItemSignoff,
+): number {
+  const leftPriority = left.items.some((item) => item.state === "signed-off")
+    ? 0
+    : 1;
+  const rightPriority = right.items.some((item) => item.state === "signed-off")
+    ? 0
+    : 1;
+
+  return leftPriority - rightPriority;
+}
+
+function normalizeSignoffNote(value: string | undefined): string | undefined {
+  const normalizedValue = value?.trim();
+
+  return normalizedValue ? normalizedValue : undefined;
+}
diff --git a/packages/replay/src/index.ts b/packages/replay/src/index.ts
index faf4beb..9be9cdf 100644
--- a/packages/replay/src/index.ts
+++ b/packages/replay/src/index.ts
@@ -117,6 +117,20 @@ export {
   normalizeChecklistItemResolutionItems,
   type UpdateCrossRunAuditCatalogChecklistItemResolutionInput,
 } from "./checklist-item-resolution";
+export {
+  type CreateCrossRunAuditCatalogChecklistItemSignoffInput,
+  type CrossRunAuditCatalogChecklistItemSignoff,
+  type CrossRunAuditCatalogChecklistItemSignoffApplication,
+  type CrossRunAuditCatalogChecklistItemSignoffCollection,
+  type CrossRunAuditCatalogChecklistItemSignoffItem,
+  type CrossRunAuditCatalogChecklistItemSignoffState,
+  type CrossRunAuditCatalogChecklistItemSignoffStore,
+  type CrossRunAuditCatalogChecklistItemSignoffView,
+  compareCrossRunAuditCatalogChecklistItemSignoff,
+  createCrossRunAuditCatalogChecklistItemSignoff,
+  normalizeChecklistItemSignoffItems,
+  type UpdateCrossRunAuditCatalogChecklistItemSignoffInput,
+} from "./checklist-item-signoff";
 export {
   type CreateCrossRunAuditCatalogChecklistItemVerificationInput,
   type CrossRunAuditCatalogChecklistItemVerification,
@@ -170,6 +184,7 @@ export {
   type CrossRunAuditCatalogChecklistItemEvidenceQuery,
   type CrossRunAuditCatalogChecklistItemProgressQuery,
   type CrossRunAuditCatalogChecklistItemResolutionQuery,
+  type CrossRunAuditCatalogChecklistItemSignoffQuery,
   type CrossRunAuditCatalogChecklistItemVerificationQuery,
   type CrossRunAuditCatalogQuery,
   type CrossRunAuditCatalogReviewAssignmentQuery,
@@ -187,6 +202,7 @@ export {
   createCrossRunAuditCatalogChecklistItemEvidenceQuery,
   createCrossRunAuditCatalogChecklistItemProgressQuery,
   createCrossRunAuditCatalogChecklistItemResolutionQuery,
+  createCrossRunAuditCatalogChecklistItemSignoffQuery,
   createCrossRunAuditCatalogChecklistItemVerificationQuery,
   createCrossRunAuditCatalogQuery,
   createCrossRunAuditCatalogReviewAssignmentQuery,
diff --git a/packages/replay/src/query.ts b/packages/replay/src/query.ts
index 83414d7..b960f24 100644
--- a/packages/replay/src/query.ts
+++ b/packages/replay/src/query.ts
@@ -91,6 +91,17 @@ import {
   normalizeChecklistItemResolutionItems,
   type UpdateCrossRunAuditCatalogChecklistItemResolutionInput,
 } from "./checklist-item-resolution";
+import {
+  type CrossRunAuditCatalogChecklistItemSignoff,
+  type CrossRunAuditCatalogChecklistItemSignoffApplication,
+  type CrossRunAuditCatalogChecklistItemSignoffCollection,
+  type CrossRunAuditCatalogChecklistItemSignoffStore,
+  type CrossRunAuditCatalogChecklistItemSignoffView,
+  compareCrossRunAuditCatalogChecklistItemSignoff,
+  createCrossRunAuditCatalogChecklistItemSignoff,
+  normalizeChecklistItemSignoffItems,
+  type UpdateCrossRunAuditCatalogChecklistItemSignoffInput,
+} from "./checklist-item-signoff";
 import {
   type CrossRunAuditCatalogChecklistItemVerification,
   type CrossRunAuditCatalogChecklistItemVerificationApplication,
@@ -470,6 +481,30 @@ export interface CrossRunAuditCatalogChecklistItemAcknowledgmentQuery {
   ): Promise<CrossRunAuditCatalogChecklistItemAcknowledgmentView>;
 }
 
+export interface CrossRunAuditCatalogChecklistItemSignoffQuery {
+  applyCatalogEntry(
+    id: string,
+    viewer: CrossRunAuditCatalogVisibilityViewer,
+  ): Promise<CrossRunAuditCatalogChecklistItemSignoffApplication | undefined>;
+  clearCatalogChecklistItemSignoff(
+    id: string,
+    viewer: CrossRunAuditCatalogVisibilityViewer,
+  ): Promise<CrossRunAuditCatalogChecklistItemSignoffView | undefined>;
+  getCatalogChecklistItemSignoff(
+    id: string,
+    viewer: CrossRunAuditCatalogVisibilityViewer,
+  ): Promise<CrossRunAuditCatalogChecklistItemSignoffView | undefined>;
+  listSignedOffCatalogEntries(
+    viewer: CrossRunAuditCatalogVisibilityViewer,
+  ): Promise<CrossRunAuditCatalogChecklistItemSignoffCollection>;
+  setCatalogChecklistItemSignoff(
+    id: string,
+    viewer: CrossRunAuditCatalogVisibilityViewer,
+    input: UpdateCrossRunAuditCatalogChecklistItemSignoffInput,
+    timestamp: string,
+  ): Promise<CrossRunAuditCatalogChecklistItemSignoffView>;
+}
+
 export interface CrossRunAuditCatalogChecklistItemAttestationQuery {
   applyCatalogEntry(
     id: string,
@@ -2292,6 +2327,156 @@ export function createCrossRunAuditCatalogChecklistItemAcknowledgmentQuery(
   };
 }
 
+export function createCrossRunAuditCatalogChecklistItemSignoffQuery(
+  store: CrossRunAuditCatalogChecklistItemSignoffStore,
+  acknowledgmentEntries: CrossRunAuditCatalogChecklistItemAcknowledgmentQuery,
+): CrossRunAuditCatalogChecklistItemSignoffQuery {
+  return {
+    async applyCatalogEntry(id, viewer) {
+      const signoff = await resolveCatalogChecklistItemSignoffView(
+        store,
+        acknowledgmentEntries,
+        id,
+        viewer,
+      );
+
+      if (!signoff) {
+        return undefined;
+      }
+
+      const application = await acknowledgmentEntries.applyCatalogEntry(
+        id,
+        viewer,
+      );
+
+      if (!application) {
+        return undefined;
+      }
+
+      return {
+        application,
+        signoff,
+      };
+    },
+
+    async clearCatalogChecklistItemSignoff(id, viewer) {
+      const signoff = await resolveCatalogChecklistItemSignoffView(
+        store,
+        acknowledgmentEntries,
+        id,
+        viewer,
+      );
+
+      if (!signoff) {
+        return undefined;
+      }
+
+      await store.deleteCatalogChecklistItemSignoff(id);
+
+      return signoff;
+    },
+
+    async getCatalogChecklistItemSignoff(id, viewer) {
+      return resolveCatalogChecklistItemSignoffView(
+        store,
+        acknowledgmentEntries,
+        id,
+        viewer,
+      );
+    },
+
+    async listSignedOffCatalogEntries(viewer) {
+      const signoffEntries = [
+        ...(await store.listCatalogChecklistItemSignoffs()),
+      ].sort(compareCrossRunAuditCatalogChecklistItemSignoff);
+      const items = (
+        await Promise.all(
+          signoffEntries.map(async (signoff) =>
+            resolveCatalogChecklistItemSignoffFromValue(
+              acknowledgmentEntries,
+              signoff,
+              viewer,
+            ),
+          ),
+        )
+      ).filter(
+        (signoff): signoff is CrossRunAuditCatalogChecklistItemSignoffView =>
+          signoff !== undefined,
+      );
+
+      return {
+        items,
+        totalCount: items.length,
+      };
+    },
+
+    async setCatalogChecklistItemSignoff(id, viewer, input, timestamp) {
+      const acknowledgment =
+        await acknowledgmentEntries.getCatalogChecklistItemAcknowledgment(
+          id,
+          viewer,
+        );
+
+      if (!acknowledgment) {
+        throw new Error(
+          `Catalog entry "${id}" is not acknowledged and visible to operator "${viewer.operatorId}".`,
+        );
+      }
+
+      const allowedItems = acknowledgment.acknowledgment.items.map(
+        (item) => item.item,
+      );
+      const normalizedItems = normalizeChecklistItemSignoffItems(
+        input.items,
+        allowedItems,
+      );
+
+      if (normalizedItems.length === 0) {
+        throw new Error(
+          "Catalog checklist item signoffs require at least one checklist item signoff entry.",
+        );
+      }
+
+      const existingSignoff = await store.getCatalogChecklistItemSignoff(id);
+      const normalizedSignoffNote = input.signoffNote?.trim();
+      const signoff = existingSignoff
+        ? {
+            ...(input.signoffNote === undefined
+              ? existingSignoff.signoffNote
+                ? { signoffNote: existingSignoff.signoffNote }
+                : {}
+              : normalizedSignoffNote
+                ? { signoffNote: normalizedSignoffNote }
+                : {}),
+            catalogEntryId: id,
+            createdAt: existingSignoff.createdAt,
+            items: normalizedItems,
+            kind: existingSignoff.kind,
+            operatorId: viewer.operatorId,
+            scopeId: viewer.scopeId,
+            updatedAt: timestamp,
+          }
+        : createCrossRunAuditCatalogChecklistItemSignoff({
+            ...(normalizedSignoffNote
+              ? { signoffNote: normalizedSignoffNote }
+              : {}),
+            catalogEntryId: id,
+            items: normalizedItems,
+            operatorId: viewer.operatorId,
+            scopeId: viewer.scopeId,
+            timestamp,
+          });
+
+      await store.saveCatalogChecklistItemSignoff(signoff);
+
+      return {
+        acknowledgment,
+        signoff,
+      };
+    },
+  };
+}
+
 async function resolveCatalogEntryView(
   store: CrossRunAuditCatalogStore,
   savedViews: CrossRunAuditSavedViewQuery,
@@ -2820,3 +3005,57 @@ async function resolveCatalogChecklistItemAcknowledgmentFromValue(
     attestation,
   };
 }
+
+async function resolveCatalogChecklistItemSignoffView(
+  store: CrossRunAuditCatalogChecklistItemSignoffStore,
+  acknowledgmentQuery: CrossRunAuditCatalogChecklistItemAcknowledgmentQuery,
+  id: string,
+  viewer: CrossRunAuditCatalogVisibilityViewer,
+): Promise<CrossRunAuditCatalogChecklistItemSignoffView | undefined> {
+  const signoff = await store.getCatalogChecklistItemSignoff(id);
+
+  return signoff
+    ? resolveCatalogChecklistItemSignoffFromValue(
+        acknowledgmentQuery,
+        signoff,
+        viewer,
+      )
+    : undefined;
+}
+
+async function resolveCatalogChecklistItemSignoffFromValue(
+  acknowledgmentQuery: CrossRunAuditCatalogChecklistItemAcknowledgmentQuery,
+  signoff: CrossRunAuditCatalogChecklistItemSignoff,
+  viewer: CrossRunAuditCatalogVisibilityViewer,
+): Promise<CrossRunAuditCatalogChecklistItemSignoffView | undefined> {
+  if (signoff.scopeId !== viewer.scopeId) {
+    return undefined;
+  }
+
+  const acknowledgment =
+    await acknowledgmentQuery.getCatalogChecklistItemAcknowledgment(
+      signoff.catalogEntryId,
+      viewer,
+    );
+
+  if (!acknowledgment) {
+    return undefined;
+  }
+
+  const normalizedItems = normalizeChecklistItemSignoffItems(
+    signoff.items,
+    acknowledgment.acknowledgment.items.map((item) => item.item),
+  );
+
+  if (normalizedItems.length === 0) {
+    return undefined;
+  }
+
+  return {
+    acknowledgment,
+    signoff: {
+      ...signoff,
+      items: normalizedItems,
+    },
+  };
+}
diff --git a/packages/sdk/src/errors.ts b/packages/sdk/src/errors.ts
index 01bd868..09c6adc 100644
--- a/packages/sdk/src/errors.ts
+++ b/packages/sdk/src/errors.ts
@@ -30,6 +30,7 @@ export class OperatorNotFoundError extends OperatorError {
       | "approval"
       | "catalog assignment checklist"
       | "catalog checklist item acknowledgment"
+      | "catalog checklist item signoff"
       | "catalog checklist item blocker"
       | "catalog checklist item attestation"
       | "catalog checklist item evidence"
diff --git a/packages/sdk/src/index.ts b/packages/sdk/src/index.ts
index 0070a89..753b245 100644
--- a/packages/sdk/src/index.ts
+++ b/packages/sdk/src/index.ts
@@ -25,6 +25,7 @@ export {
   type RunrootOperatorServiceOptions,
   resolveWorkspacePath,
   type SaveAuditSavedViewInput,
+  type SignOffAuditCatalogEntryInput,
   type StartTemplateRunInput,
   type VerifyAuditCatalogEntryInput,
 } from "./operator-service";
diff --git a/packages/sdk/src/operator-service.integration.test.ts b/packages/sdk/src/operator-service.integration.test.ts
index 6d33b58..af1887d 100644
--- a/packages/sdk/src/operator-service.integration.test.ts
+++ b/packages/sdk/src/operator-service.integration.test.ts
@@ -2876,7 +2876,41 @@ describe("@runroot/sdk operator service integration", () => {
         },
       ],
     });
+    await ownerService.signOffCatalogEntry(inlineCatalogEntry.entry.id, {
+      items: [
+        {
+          item: "Confirm inline owner follow-up",
+          state: "signed-off",
+        },
+      ],
+    });
+    await ownerService.signOffCatalogEntry(queuedCatalogEntry.entry.id, {
+      signoffNote: "Backup signed off the acknowledged follow-up",
+      items: [
+        {
+          item: "Validate queued follow-up",
+          state: "signed-off",
+        },
+        {
+          item: "Close backup handoff",
+          state: "unsigned",
+        },
+      ],
+    });
 
+    const ownerSignoffs = await ownerService.listSignedOffCatalogEntries();
+    const peerSignoffs = await peerService.listSignedOffCatalogEntries();
+    const inspectedSignoff = await ownerService.getCatalogChecklistItemSignoff(
+      queuedCatalogEntry.entry.id,
+    );
+    const appliedSignoff = await peerService.applyCatalogEntry(
+      queuedCatalogEntry.entry.id,
+    );
+    const clearedSignoff = await ownerService.clearCatalogChecklistItemSignoff(
+      queuedCatalogEntry.entry.id,
+    );
+    const peerSignoffsAfterClear =
+      await peerService.listSignedOffCatalogEntries();
     const ownerAcknowledgments =
       await ownerService.listAcknowledgedCatalogEntries();
     const peerAcknowledgments =
@@ -2895,6 +2929,50 @@ describe("@runroot/sdk operator service integration", () => {
     const peerAcknowledgmentsAfterClear =
       await peerService.listAcknowledgedCatalogEntries();
 
+    expect(
+      ownerSignoffs.items.map(
+        (item) =>
+          item.acknowledgment.attestation.evidence.verification.resolution
+            .blocker.progress.checklist.assignment.review.visibility
+            .catalogEntry.entry.id,
+      ),
+    ).toEqual([queuedCatalogEntry.entry.id, inlineCatalogEntry.entry.id]);
+    expect(
+      peerSignoffs.items.map(
+        (item) =>
+          item.acknowledgment.attestation.evidence.verification.resolution
+            .blocker.progress.checklist.assignment.review.visibility
+            .catalogEntry.entry.id,
+      ),
+    ).toEqual([queuedCatalogEntry.entry.id]);
+    expect(inspectedSignoff.signoff).toMatchObject({
+      catalogEntryId: queuedCatalogEntry.entry.id,
+      operatorId: "ops_oncall",
+      scopeId: "ops",
+      signoffNote: "Backup signed off the acknowledged follow-up",
+    });
+    expect(inspectedSignoff.signoff.items).toEqual([
+      {
+        item: "Validate queued follow-up",
+        state: "signed-off",
+      },
+      {
+        item: "Close backup handoff",
+        state: "unsigned",
+      },
+    ]);
+    expect(appliedSignoff.catalogEntry.entry.id).toBe(
+      queuedCatalogEntry.entry.id,
+    );
+    expect(appliedSignoff.application.savedView.id).toBe(queuedSavedView.id);
+    expect(appliedSignoff.application.navigation.totalSummaryCount).toBe(1);
+    expect(
+      appliedSignoff.application.navigation.drilldowns[0]?.result.runId,
+    ).toBe(queuedRun.id);
+    expect(clearedSignoff.signoff.catalogEntryId).toBe(
+      queuedCatalogEntry.entry.id,
+    );
+    expect(peerSignoffsAfterClear.totalCount).toBe(0);
     expect(
       ownerAcknowledgments.items.map(
         (item) =>
diff --git a/packages/sdk/src/operator-service.ts b/packages/sdk/src/operator-service.ts
index cdb20e1..ad18b3e 100644
--- a/packages/sdk/src/operator-service.ts
+++ b/packages/sdk/src/operator-service.ts
@@ -25,6 +25,7 @@ import {
   createConfiguredAuditCatalogChecklistItemEvidenceStore,
   createConfiguredAuditCatalogChecklistItemProgressStore,
   createConfiguredAuditCatalogChecklistItemResolutionStore,
+  createConfiguredAuditCatalogChecklistItemSignoffStore,
   createConfiguredAuditCatalogChecklistItemVerificationStore,
   createConfiguredAuditCatalogReviewAssignmentStore,
   createConfiguredAuditCatalogReviewSignalStore,
@@ -65,6 +66,10 @@ import {
   type CrossRunAuditCatalogChecklistItemResolutionItem,
   type CrossRunAuditCatalogChecklistItemResolutionStore,
   type CrossRunAuditCatalogChecklistItemResolutionView,
+  type CrossRunAuditCatalogChecklistItemSignoffCollection,
+  type CrossRunAuditCatalogChecklistItemSignoffItem,
+  type CrossRunAuditCatalogChecklistItemSignoffStore,
+  type CrossRunAuditCatalogChecklistItemSignoffView,
   type CrossRunAuditCatalogChecklistItemVerificationCollection,
   type CrossRunAuditCatalogChecklistItemVerificationItem,
   type CrossRunAuditCatalogChecklistItemVerificationStore,
@@ -102,6 +107,7 @@ import {
   createCrossRunAuditCatalogChecklistItemEvidenceQuery,
   createCrossRunAuditCatalogChecklistItemProgressQuery,
   createCrossRunAuditCatalogChecklistItemResolutionQuery,
+  createCrossRunAuditCatalogChecklistItemSignoffQuery,
   createCrossRunAuditCatalogChecklistItemVerificationQuery,
   createCrossRunAuditCatalogQuery,
   createCrossRunAuditCatalogReviewAssignmentQuery,
@@ -217,6 +223,11 @@ export interface AcknowledgeAuditCatalogEntryInput {
   readonly items: readonly CrossRunAuditCatalogChecklistItemAcknowledgmentItem[];
 }
 
+export interface SignOffAuditCatalogEntryInput {
+  readonly signoffNote?: string;
+  readonly items: readonly CrossRunAuditCatalogChecklistItemSignoffItem[];
+}
+
 export interface ReviewAuditCatalogEntryInput {
   readonly note?: string;
   readonly state: CrossRunAuditCatalogReviewState;
@@ -245,6 +256,10 @@ export interface RunrootOperatorService {
     id: string,
     input: AttestAuditCatalogEntryInput,
   ): Promise<CrossRunAuditCatalogChecklistItemAttestationView>;
+  signOffCatalogEntry(
+    id: string,
+    input: SignOffAuditCatalogEntryInput,
+  ): Promise<CrossRunAuditCatalogChecklistItemSignoffView>;
   acknowledgeCatalogEntry(
     id: string,
     input: AcknowledgeAuditCatalogEntryInput,
@@ -270,6 +285,9 @@ export interface RunrootOperatorService {
   clearCatalogChecklistItemAttestation(
     id: string,
   ): Promise<CrossRunAuditCatalogChecklistItemAttestationView>;
+  clearCatalogChecklistItemSignoff(
+    id: string,
+  ): Promise<CrossRunAuditCatalogChecklistItemSignoffView>;
   clearCatalogChecklistItemAcknowledgment(
     id: string,
   ): Promise<CrossRunAuditCatalogChecklistItemAcknowledgmentView>;
@@ -300,6 +318,9 @@ export interface RunrootOperatorService {
   getCatalogChecklistItemAttestation(
     id: string,
   ): Promise<CrossRunAuditCatalogChecklistItemAttestationView>;
+  getCatalogChecklistItemSignoff(
+    id: string,
+  ): Promise<CrossRunAuditCatalogChecklistItemSignoffView>;
   getCatalogChecklistItemAcknowledgment(
     id: string,
   ): Promise<CrossRunAuditCatalogChecklistItemAcknowledgmentView>;
@@ -340,6 +361,7 @@ export interface RunrootOperatorService {
     filters?: CrossRunAuditDrilldownFilters,
   ): Promise<CrossRunAuditDrilldownResults>;
   listAssignedCatalogEntries(): Promise<CrossRunAuditCatalogReviewAssignmentCollection>;
+  listSignedOffCatalogEntries(): Promise<CrossRunAuditCatalogChecklistItemSignoffCollection>;
   listAcknowledgedCatalogEntries(): Promise<CrossRunAuditCatalogChecklistItemAcknowledgmentCollection>;
   listBlockedCatalogEntries(): Promise<CrossRunAuditCatalogChecklistItemBlockerCollection>;
   listChecklistedCatalogEntries(): Promise<CrossRunAuditCatalogAssignmentChecklistCollection>;
@@ -380,6 +402,7 @@ export interface RunrootOperatorService {
 export interface RunrootOperatorServiceOptions {
   readonly approvalIdGenerator?: () => string;
   readonly catalogAssignmentChecklistStore?: CrossRunAuditCatalogAssignmentChecklistStore;
+  readonly catalogChecklistItemSignoffStore?: CrossRunAuditCatalogChecklistItemSignoffStore;
   readonly catalogChecklistItemAcknowledgmentStore?: CrossRunAuditCatalogChecklistItemAcknowledgmentStore;
   readonly catalogChecklistItemAttestationStore?: CrossRunAuditCatalogChecklistItemAttestationStore;
   readonly catalogChecklistItemBlockerStore?: CrossRunAuditCatalogChecklistItemBlockerStore;
@@ -601,6 +624,19 @@ export function createRunrootOperatorService(
         ? { workspacePath: options.workspacePath }
         : {}),
     });
+  const catalogChecklistItemSignoffStore =
+    options.catalogChecklistItemSignoffStore ??
+    createConfiguredAuditCatalogChecklistItemSignoffStore({
+      ...(options.databaseUrl ? { databaseUrl: options.databaseUrl } : {}),
+      ...(options.env ? { env: options.env } : {}),
+      ...(options.persistenceDriver
+        ? { driver: options.persistenceDriver }
+        : {}),
+      ...(options.sqlitePath ? { sqlitePath: options.sqlitePath } : {}),
+      ...(options.workspacePath
+        ? { workspacePath: options.workspacePath }
+        : {}),
+    });
   const catalogChecklistItemAcknowledgmentStore =
     options.catalogChecklistItemAcknowledgmentStore ??
     createConfiguredAuditCatalogChecklistItemAcknowledgmentStore({
@@ -772,6 +808,11 @@ export function createRunrootOperatorService(
       catalogChecklistItemAcknowledgmentStore,
       crossRunAuditCatalogChecklistItemAttestations,
     );
+  const crossRunAuditCatalogChecklistItemSignoffs =
+    createCrossRunAuditCatalogChecklistItemSignoffQuery(
+      catalogChecklistItemSignoffStore,
+      crossRunAuditCatalogChecklistItemAcknowledgments,
+    );
   const persistenceLocation = persistenceConfig.location;
 
   return {
@@ -877,6 +918,19 @@ export function createRunrootOperatorService(
       }
     },
 
+    async signOffCatalogEntry(id, input) {
+      try {
+        return await crossRunAuditCatalogChecklistItemSignoffs.setCatalogChecklistItemSignoff(
+          id,
+          operatorIdentity,
+          input,
+          now(),
+        );
+      } catch (error) {
+        throw normalizeCatalogChecklistItemSignoffError(error, id);
+      }
+    },
+
     async recordCatalogEntryEvidence(id, input) {
       try {
         return await crossRunAuditCatalogChecklistItemEvidence.setCatalogChecklistItemEvidence(
@@ -1000,6 +1054,20 @@ export function createRunrootOperatorService(
       return acknowledgment;
     },
 
+    async clearCatalogChecklistItemSignoff(id) {
+      const signoff =
+        await crossRunAuditCatalogChecklistItemSignoffs.clearCatalogChecklistItemSignoff(
+          id,
+          operatorIdentity,
+        );
+
+      if (!signoff) {
+        throw new OperatorNotFoundError("catalog checklist item signoff", id);
+      }
+
+      return signoff;
+    },
+
     async clearCatalogChecklistItemEvidence(id) {
       const evidence =
         await crossRunAuditCatalogChecklistItemEvidence.clearCatalogChecklistItemEvidence(
@@ -1206,6 +1274,20 @@ export function createRunrootOperatorService(
       return acknowledgment;
     },
 
+    async getCatalogChecklistItemSignoff(id) {
+      const signoff =
+        await crossRunAuditCatalogChecklistItemSignoffs.getCatalogChecklistItemSignoff(
+          id,
+          operatorIdentity,
+        );
+
+      if (!signoff) {
+        throw new OperatorNotFoundError("catalog checklist item signoff", id);
+      }
+
+      return signoff;
+    },
+
     async getCatalogChecklistItemEvidence(id) {
       const evidence =
         await crossRunAuditCatalogChecklistItemEvidence.getCatalogChecklistItemEvidence(
@@ -1375,6 +1457,12 @@ export function createRunrootOperatorService(
       );
     },
 
+    async listSignedOffCatalogEntries() {
+      return crossRunAuditCatalogChecklistItemSignoffs.listSignedOffCatalogEntries(
+        operatorIdentity,
+      );
+    },
+
     async listEvidencedCatalogEntries() {
       return crossRunAuditCatalogChecklistItemEvidence.listEvidencedCatalogEntries(
         operatorIdentity,
@@ -2058,6 +2146,44 @@ function normalizeCatalogChecklistItemAcknowledgmentError(
   return normalizeOperatorError(error);
 }
 
+function normalizeCatalogChecklistItemSignoffError(
+  error: unknown,
+  catalogEntryId: string,
+): Error {
+  if (
+    error instanceof OperatorConflictError ||
+    error instanceof OperatorInputError ||
+    error instanceof OperatorNotFoundError
+  ) {
+    return error;
+  }
+
+  if (
+    error instanceof Error &&
+    (error.message.startsWith("Catalog checklist item signoffs require") ||
+      error.message.startsWith(`Catalog checklist item signoff "`) ||
+      error.message.startsWith(
+        `Catalog entry "${catalogEntryId}" does not define checklist item acknowledgment entries`,
+      ))
+  ) {
+    return new OperatorInputError(error.message);
+  }
+
+  if (
+    error instanceof Error &&
+    error.message.startsWith(
+      `Catalog entry "${catalogEntryId}" is not acknowledged and visible to operator`,
+    )
+  ) {
+    return new OperatorNotFoundError(
+      "catalog checklist item signoff",
+      catalogEntryId,
+    );
+  }
+
+  return normalizeOperatorError(error);
+}
+
 function normalizeCatalogReviewSignalError(
   error: unknown,
   catalogEntryId: string,